File: | tools/clang/lib/AST/DeclBase.cpp |
Location: | line 1637, column 45 |
Description: | Potential memory leak |
1 | //===--- DeclBase.cpp - Declaration AST Node Implementation ---------------===// | |||
2 | // | |||
3 | // The LLVM Compiler Infrastructure | |||
4 | // | |||
5 | // This file is distributed under the University of Illinois Open Source | |||
6 | // License. See LICENSE.TXT for details. | |||
7 | // | |||
8 | //===----------------------------------------------------------------------===// | |||
9 | // | |||
10 | // This file implements the Decl and DeclContext classes. | |||
11 | // | |||
12 | //===----------------------------------------------------------------------===// | |||
13 | ||||
14 | #include "clang/AST/DeclBase.h" | |||
15 | #include "clang/AST/ASTContext.h" | |||
16 | #include "clang/AST/ASTMutationListener.h" | |||
17 | #include "clang/AST/Attr.h" | |||
18 | #include "clang/AST/Decl.h" | |||
19 | #include "clang/AST/DeclCXX.h" | |||
20 | #include "clang/AST/DeclContextInternals.h" | |||
21 | #include "clang/AST/DeclFriend.h" | |||
22 | #include "clang/AST/DeclObjC.h" | |||
23 | #include "clang/AST/DeclOpenMP.h" | |||
24 | #include "clang/AST/DeclTemplate.h" | |||
25 | #include "clang/AST/DependentDiagnostic.h" | |||
26 | #include "clang/AST/ExternalASTSource.h" | |||
27 | #include "clang/AST/Stmt.h" | |||
28 | #include "clang/AST/StmtCXX.h" | |||
29 | #include "clang/AST/Type.h" | |||
30 | #include "clang/Basic/TargetInfo.h" | |||
31 | #include "llvm/ADT/DenseMap.h" | |||
32 | #include "llvm/Support/raw_ostream.h" | |||
33 | #include <algorithm> | |||
34 | using namespace clang; | |||
35 | ||||
36 | //===----------------------------------------------------------------------===// | |||
37 | // Statistics | |||
38 | //===----------------------------------------------------------------------===// | |||
39 | ||||
40 | #define DECL(DERIVED, BASE) static int n##DERIVED##s = 0; | |||
41 | #define ABSTRACT_DECL(DECL) | |||
42 | #include "clang/AST/DeclNodes.inc" | |||
43 | ||||
44 | void Decl::updateOutOfDate(IdentifierInfo &II) const { | |||
45 | getASTContext().getExternalSource()->updateOutOfDateIdentifier(II); | |||
46 | } | |||
47 | ||||
48 | void *Decl::operator new(std::size_t Size, const ASTContext &Context, | |||
49 | unsigned ID, std::size_t Extra) { | |||
50 | // Allocate an extra 8 bytes worth of storage, which ensures that the | |||
51 | // resulting pointer will still be 8-byte aligned. | |||
52 | void *Start = Context.Allocate(Size + Extra + 8); | |||
53 | void *Result = (char*)Start + 8; | |||
54 | ||||
55 | unsigned *PrefixPtr = (unsigned *)Result - 2; | |||
56 | ||||
57 | // Zero out the first 4 bytes; this is used to store the owning module ID. | |||
58 | PrefixPtr[0] = 0; | |||
59 | ||||
60 | // Store the global declaration ID in the second 4 bytes. | |||
61 | PrefixPtr[1] = ID; | |||
62 | ||||
63 | return Result; | |||
64 | } | |||
65 | ||||
66 | void *Decl::operator new(std::size_t Size, const ASTContext &Ctx, | |||
67 | DeclContext *Parent, std::size_t Extra) { | |||
68 | assert(!Parent || &Parent->getParentASTContext() == &Ctx)((!Parent || &Parent->getParentASTContext() == &Ctx ) ? static_cast<void> (0) : __assert_fail ("!Parent || &Parent->getParentASTContext() == &Ctx" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 68, __PRETTY_FUNCTION__)); | |||
69 | return ::operator new(Size + Extra, Ctx); | |||
70 | } | |||
71 | ||||
72 | Module *Decl::getOwningModuleSlow() const { | |||
73 | assert(isFromASTFile() && "Not from AST file?")((isFromASTFile() && "Not from AST file?") ? static_cast <void> (0) : __assert_fail ("isFromASTFile() && \"Not from AST file?\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 73, __PRETTY_FUNCTION__)); | |||
74 | return getASTContext().getExternalSource()->getModule(getOwningModuleID()); | |||
75 | } | |||
76 | ||||
77 | const char *Decl::getDeclKindName() const { | |||
78 | switch (DeclKind) { | |||
79 | default: llvm_unreachable("Declaration not in DeclNodes.inc!")::llvm::llvm_unreachable_internal("Declaration not in DeclNodes.inc!" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 79); | |||
80 | #define DECL(DERIVED, BASE) case DERIVED: return #DERIVED; | |||
81 | #define ABSTRACT_DECL(DECL) | |||
82 | #include "clang/AST/DeclNodes.inc" | |||
83 | } | |||
84 | } | |||
85 | ||||
86 | void Decl::setInvalidDecl(bool Invalid) { | |||
87 | InvalidDecl = Invalid; | |||
88 | assert(!isa<TagDecl>(this) || !cast<TagDecl>(this)->isCompleteDefinition())((!isa<TagDecl>(this) || !cast<TagDecl>(this)-> isCompleteDefinition()) ? static_cast<void> (0) : __assert_fail ("!isa<TagDecl>(this) || !cast<TagDecl>(this)->isCompleteDefinition()" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 88, __PRETTY_FUNCTION__)); | |||
89 | if (Invalid && !isa<ParmVarDecl>(this)) { | |||
90 | // Defensive maneuver for ill-formed code: we're likely not to make it to | |||
91 | // a point where we set the access specifier, so default it to "public" | |||
92 | // to avoid triggering asserts elsewhere in the front end. | |||
93 | setAccess(AS_public); | |||
94 | } | |||
95 | } | |||
96 | ||||
97 | const char *DeclContext::getDeclKindName() const { | |||
98 | switch (DeclKind) { | |||
99 | default: llvm_unreachable("Declaration context not in DeclNodes.inc!")::llvm::llvm_unreachable_internal("Declaration context not in DeclNodes.inc!" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 99); | |||
100 | #define DECL(DERIVED, BASE) case Decl::DERIVED: return #DERIVED; | |||
101 | #define ABSTRACT_DECL(DECL) | |||
102 | #include "clang/AST/DeclNodes.inc" | |||
103 | } | |||
104 | } | |||
105 | ||||
106 | bool Decl::StatisticsEnabled = false; | |||
107 | void Decl::EnableStatistics() { | |||
108 | StatisticsEnabled = true; | |||
109 | } | |||
110 | ||||
111 | void Decl::PrintStats() { | |||
112 | llvm::errs() << "\n*** Decl Stats:\n"; | |||
113 | ||||
114 | int totalDecls = 0; | |||
115 | #define DECL(DERIVED, BASE) totalDecls += n##DERIVED##s; | |||
116 | #define ABSTRACT_DECL(DECL) | |||
117 | #include "clang/AST/DeclNodes.inc" | |||
118 | llvm::errs() << " " << totalDecls << " decls total.\n"; | |||
119 | ||||
120 | int totalBytes = 0; | |||
121 | #define DECL(DERIVED, BASE) \ | |||
122 | if (n##DERIVED##s > 0) { \ | |||
123 | totalBytes += (int)(n##DERIVED##s * sizeof(DERIVED##Decl)); \ | |||
124 | llvm::errs() << " " << n##DERIVED##s << " " #DERIVED " decls, " \ | |||
125 | << sizeof(DERIVED##Decl) << " each (" \ | |||
126 | << n##DERIVED##s * sizeof(DERIVED##Decl) \ | |||
127 | << " bytes)\n"; \ | |||
128 | } | |||
129 | #define ABSTRACT_DECL(DECL) | |||
130 | #include "clang/AST/DeclNodes.inc" | |||
131 | ||||
132 | llvm::errs() << "Total bytes = " << totalBytes << "\n"; | |||
133 | } | |||
134 | ||||
135 | void Decl::add(Kind k) { | |||
136 | switch (k) { | |||
137 | #define DECL(DERIVED, BASE) case DERIVED: ++n##DERIVED##s; break; | |||
138 | #define ABSTRACT_DECL(DECL) | |||
139 | #include "clang/AST/DeclNodes.inc" | |||
140 | } | |||
141 | } | |||
142 | ||||
143 | bool Decl::isTemplateParameterPack() const { | |||
144 | if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(this)) | |||
145 | return TTP->isParameterPack(); | |||
146 | if (const NonTypeTemplateParmDecl *NTTP | |||
147 | = dyn_cast<NonTypeTemplateParmDecl>(this)) | |||
148 | return NTTP->isParameterPack(); | |||
149 | if (const TemplateTemplateParmDecl *TTP | |||
150 | = dyn_cast<TemplateTemplateParmDecl>(this)) | |||
151 | return TTP->isParameterPack(); | |||
152 | return false; | |||
153 | } | |||
154 | ||||
155 | bool Decl::isParameterPack() const { | |||
156 | if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(this)) | |||
157 | return Parm->isParameterPack(); | |||
158 | ||||
159 | return isTemplateParameterPack(); | |||
160 | } | |||
161 | ||||
162 | FunctionDecl *Decl::getAsFunction() { | |||
163 | if (FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) | |||
164 | return FD; | |||
165 | if (const FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(this)) | |||
166 | return FTD->getTemplatedDecl(); | |||
167 | return nullptr; | |||
168 | } | |||
169 | ||||
170 | bool Decl::isTemplateDecl() const { | |||
171 | return isa<TemplateDecl>(this); | |||
172 | } | |||
173 | ||||
174 | const DeclContext *Decl::getParentFunctionOrMethod() const { | |||
175 | for (const DeclContext *DC = getDeclContext(); | |||
176 | DC && !DC->isTranslationUnit() && !DC->isNamespace(); | |||
177 | DC = DC->getParent()) | |||
178 | if (DC->isFunctionOrMethod()) | |||
179 | return DC; | |||
180 | ||||
181 | return nullptr; | |||
182 | } | |||
183 | ||||
184 | ||||
185 | //===----------------------------------------------------------------------===// | |||
186 | // PrettyStackTraceDecl Implementation | |||
187 | //===----------------------------------------------------------------------===// | |||
188 | ||||
189 | void PrettyStackTraceDecl::print(raw_ostream &OS) const { | |||
190 | SourceLocation TheLoc = Loc; | |||
191 | if (TheLoc.isInvalid() && TheDecl) | |||
192 | TheLoc = TheDecl->getLocation(); | |||
193 | ||||
194 | if (TheLoc.isValid()) { | |||
195 | TheLoc.print(OS, SM); | |||
196 | OS << ": "; | |||
197 | } | |||
198 | ||||
199 | OS << Message; | |||
200 | ||||
201 | if (const NamedDecl *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) { | |||
202 | OS << " '"; | |||
203 | DN->printQualifiedName(OS); | |||
204 | OS << '\''; | |||
205 | } | |||
206 | OS << '\n'; | |||
207 | } | |||
208 | ||||
209 | //===----------------------------------------------------------------------===// | |||
210 | // Decl Implementation | |||
211 | //===----------------------------------------------------------------------===// | |||
212 | ||||
213 | // Out-of-line virtual method providing a home for Decl. | |||
214 | Decl::~Decl() { } | |||
215 | ||||
216 | void Decl::setDeclContext(DeclContext *DC) { | |||
217 | DeclCtx = DC; | |||
218 | } | |||
219 | ||||
220 | void Decl::setLexicalDeclContext(DeclContext *DC) { | |||
221 | if (DC == getLexicalDeclContext()) | |||
222 | return; | |||
223 | ||||
224 | if (isInSemaDC()) { | |||
225 | setDeclContextsImpl(getDeclContext(), DC, getASTContext()); | |||
226 | } else { | |||
227 | getMultipleDC()->LexicalDC = DC; | |||
228 | } | |||
229 | } | |||
230 | ||||
231 | void Decl::setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC, | |||
232 | ASTContext &Ctx) { | |||
233 | if (SemaDC == LexicalDC) { | |||
234 | DeclCtx = SemaDC; | |||
235 | } else { | |||
236 | Decl::MultipleDC *MDC = new (Ctx) Decl::MultipleDC(); | |||
237 | MDC->SemanticDC = SemaDC; | |||
238 | MDC->LexicalDC = LexicalDC; | |||
239 | DeclCtx = MDC; | |||
240 | } | |||
241 | } | |||
242 | ||||
243 | bool Decl::isInAnonymousNamespace() const { | |||
244 | const DeclContext *DC = getDeclContext(); | |||
245 | do { | |||
246 | if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC)) | |||
247 | if (ND->isAnonymousNamespace()) | |||
248 | return true; | |||
249 | } while ((DC = DC->getParent())); | |||
250 | ||||
251 | return false; | |||
252 | } | |||
253 | ||||
254 | bool Decl::isInStdNamespace() const { | |||
255 | return getDeclContext()->isStdNamespace(); | |||
256 | } | |||
257 | ||||
258 | TranslationUnitDecl *Decl::getTranslationUnitDecl() { | |||
259 | if (TranslationUnitDecl *TUD = dyn_cast<TranslationUnitDecl>(this)) | |||
260 | return TUD; | |||
261 | ||||
262 | DeclContext *DC = getDeclContext(); | |||
263 | assert(DC && "This decl is not contained in a translation unit!")((DC && "This decl is not contained in a translation unit!" ) ? static_cast<void> (0) : __assert_fail ("DC && \"This decl is not contained in a translation unit!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 263, __PRETTY_FUNCTION__)); | |||
264 | ||||
265 | while (!DC->isTranslationUnit()) { | |||
266 | DC = DC->getParent(); | |||
267 | assert(DC && "This decl is not contained in a translation unit!")((DC && "This decl is not contained in a translation unit!" ) ? static_cast<void> (0) : __assert_fail ("DC && \"This decl is not contained in a translation unit!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 267, __PRETTY_FUNCTION__)); | |||
268 | } | |||
269 | ||||
270 | return cast<TranslationUnitDecl>(DC); | |||
271 | } | |||
272 | ||||
273 | ASTContext &Decl::getASTContext() const { | |||
274 | return getTranslationUnitDecl()->getASTContext(); | |||
275 | } | |||
276 | ||||
277 | ASTMutationListener *Decl::getASTMutationListener() const { | |||
278 | return getASTContext().getASTMutationListener(); | |||
279 | } | |||
280 | ||||
281 | unsigned Decl::getMaxAlignment() const { | |||
282 | if (!hasAttrs()) | |||
283 | return 0; | |||
284 | ||||
285 | unsigned Align = 0; | |||
286 | const AttrVec &V = getAttrs(); | |||
287 | ASTContext &Ctx = getASTContext(); | |||
288 | specific_attr_iterator<AlignedAttr> I(V.begin()), E(V.end()); | |||
289 | for (; I != E; ++I) | |||
290 | Align = std::max(Align, I->getAlignment(Ctx)); | |||
291 | return Align; | |||
292 | } | |||
293 | ||||
294 | bool Decl::isUsed(bool CheckUsedAttr) const { | |||
295 | if (Used) | |||
296 | return true; | |||
297 | ||||
298 | // Check for used attribute. | |||
299 | if (CheckUsedAttr && hasAttr<UsedAttr>()) | |||
300 | return true; | |||
301 | ||||
302 | return false; | |||
303 | } | |||
304 | ||||
305 | void Decl::markUsed(ASTContext &C) { | |||
306 | if (Used) | |||
307 | return; | |||
308 | ||||
309 | if (C.getASTMutationListener()) | |||
310 | C.getASTMutationListener()->DeclarationMarkedUsed(this); | |||
311 | ||||
312 | Used = true; | |||
313 | } | |||
314 | ||||
315 | bool Decl::isReferenced() const { | |||
316 | if (Referenced) | |||
317 | return true; | |||
318 | ||||
319 | // Check redeclarations. | |||
320 | for (auto I : redecls()) | |||
321 | if (I->Referenced) | |||
322 | return true; | |||
323 | ||||
324 | return false; | |||
325 | } | |||
326 | ||||
327 | /// \brief Determine the availability of the given declaration based on | |||
328 | /// the target platform. | |||
329 | /// | |||
330 | /// When it returns an availability result other than \c AR_Available, | |||
331 | /// if the \p Message parameter is non-NULL, it will be set to a | |||
332 | /// string describing why the entity is unavailable. | |||
333 | /// | |||
334 | /// FIXME: Make these strings localizable, since they end up in | |||
335 | /// diagnostics. | |||
336 | static AvailabilityResult CheckAvailability(ASTContext &Context, | |||
337 | const AvailabilityAttr *A, | |||
338 | std::string *Message) { | |||
339 | StringRef TargetPlatform = Context.getTargetInfo().getPlatformName(); | |||
340 | StringRef PrettyPlatformName | |||
341 | = AvailabilityAttr::getPrettyPlatformName(TargetPlatform); | |||
342 | if (PrettyPlatformName.empty()) | |||
343 | PrettyPlatformName = TargetPlatform; | |||
344 | ||||
345 | VersionTuple TargetMinVersion = Context.getTargetInfo().getPlatformMinVersion(); | |||
346 | if (TargetMinVersion.empty()) | |||
347 | return AR_Available; | |||
348 | ||||
349 | // Match the platform name. | |||
350 | if (A->getPlatform()->getName() != TargetPlatform) | |||
351 | return AR_Available; | |||
352 | ||||
353 | std::string HintMessage; | |||
354 | if (!A->getMessage().empty()) { | |||
355 | HintMessage = " - "; | |||
356 | HintMessage += A->getMessage(); | |||
357 | } | |||
358 | ||||
359 | // Make sure that this declaration has not been marked 'unavailable'. | |||
360 | if (A->getUnavailable()) { | |||
361 | if (Message) { | |||
362 | Message->clear(); | |||
363 | llvm::raw_string_ostream Out(*Message); | |||
364 | Out << "not available on " << PrettyPlatformName | |||
365 | << HintMessage; | |||
366 | } | |||
367 | ||||
368 | return AR_Unavailable; | |||
369 | } | |||
370 | ||||
371 | // Make sure that this declaration has already been introduced. | |||
372 | if (!A->getIntroduced().empty() && | |||
373 | TargetMinVersion < A->getIntroduced()) { | |||
374 | if (Message) { | |||
375 | Message->clear(); | |||
376 | llvm::raw_string_ostream Out(*Message); | |||
377 | VersionTuple VTI(A->getIntroduced()); | |||
378 | VTI.UseDotAsSeparator(); | |||
379 | Out << "introduced in " << PrettyPlatformName << ' ' | |||
380 | << VTI << HintMessage; | |||
381 | } | |||
382 | ||||
383 | return AR_NotYetIntroduced; | |||
384 | } | |||
385 | ||||
386 | // Make sure that this declaration hasn't been obsoleted. | |||
387 | if (!A->getObsoleted().empty() && TargetMinVersion >= A->getObsoleted()) { | |||
388 | if (Message) { | |||
389 | Message->clear(); | |||
390 | llvm::raw_string_ostream Out(*Message); | |||
391 | VersionTuple VTO(A->getObsoleted()); | |||
392 | VTO.UseDotAsSeparator(); | |||
393 | Out << "obsoleted in " << PrettyPlatformName << ' ' | |||
394 | << VTO << HintMessage; | |||
395 | } | |||
396 | ||||
397 | return AR_Unavailable; | |||
398 | } | |||
399 | ||||
400 | // Make sure that this declaration hasn't been deprecated. | |||
401 | if (!A->getDeprecated().empty() && TargetMinVersion >= A->getDeprecated()) { | |||
402 | if (Message) { | |||
403 | Message->clear(); | |||
404 | llvm::raw_string_ostream Out(*Message); | |||
405 | VersionTuple VTD(A->getDeprecated()); | |||
406 | VTD.UseDotAsSeparator(); | |||
407 | Out << "first deprecated in " << PrettyPlatformName << ' ' | |||
408 | << VTD << HintMessage; | |||
409 | } | |||
410 | ||||
411 | return AR_Deprecated; | |||
412 | } | |||
413 | ||||
414 | return AR_Available; | |||
415 | } | |||
416 | ||||
417 | AvailabilityResult Decl::getAvailability(std::string *Message) const { | |||
418 | AvailabilityResult Result = AR_Available; | |||
419 | std::string ResultMessage; | |||
420 | ||||
421 | for (const auto *A : attrs()) { | |||
422 | if (const auto *Deprecated = dyn_cast<DeprecatedAttr>(A)) { | |||
423 | if (Result >= AR_Deprecated) | |||
424 | continue; | |||
425 | ||||
426 | if (Message) | |||
427 | ResultMessage = Deprecated->getMessage(); | |||
428 | ||||
429 | Result = AR_Deprecated; | |||
430 | continue; | |||
431 | } | |||
432 | ||||
433 | if (const auto *Unavailable = dyn_cast<UnavailableAttr>(A)) { | |||
434 | if (Message) | |||
435 | *Message = Unavailable->getMessage(); | |||
436 | return AR_Unavailable; | |||
437 | } | |||
438 | ||||
439 | if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) { | |||
440 | AvailabilityResult AR = CheckAvailability(getASTContext(), Availability, | |||
441 | Message); | |||
442 | ||||
443 | if (AR == AR_Unavailable) | |||
444 | return AR_Unavailable; | |||
445 | ||||
446 | if (AR > Result) { | |||
447 | Result = AR; | |||
448 | if (Message) | |||
449 | ResultMessage.swap(*Message); | |||
450 | } | |||
451 | continue; | |||
452 | } | |||
453 | } | |||
454 | ||||
455 | if (Message) | |||
456 | Message->swap(ResultMessage); | |||
457 | return Result; | |||
458 | } | |||
459 | ||||
460 | bool Decl::canBeWeakImported(bool &IsDefinition) const { | |||
461 | IsDefinition = false; | |||
462 | ||||
463 | // Variables, if they aren't definitions. | |||
464 | if (const VarDecl *Var = dyn_cast<VarDecl>(this)) { | |||
465 | if (Var->isThisDeclarationADefinition()) { | |||
466 | IsDefinition = true; | |||
467 | return false; | |||
468 | } | |||
469 | return true; | |||
470 | ||||
471 | // Functions, if they aren't definitions. | |||
472 | } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) { | |||
473 | if (FD->hasBody()) { | |||
474 | IsDefinition = true; | |||
475 | return false; | |||
476 | } | |||
477 | return true; | |||
478 | ||||
479 | // Objective-C classes, if this is the non-fragile runtime. | |||
480 | } else if (isa<ObjCInterfaceDecl>(this) && | |||
481 | getASTContext().getLangOpts().ObjCRuntime.hasWeakClassImport()) { | |||
482 | return true; | |||
483 | ||||
484 | // Nothing else. | |||
485 | } else { | |||
486 | return false; | |||
487 | } | |||
488 | } | |||
489 | ||||
490 | bool Decl::isWeakImported() const { | |||
491 | bool IsDefinition; | |||
492 | if (!canBeWeakImported(IsDefinition)) | |||
493 | return false; | |||
494 | ||||
495 | for (const auto *A : attrs()) { | |||
496 | if (isa<WeakImportAttr>(A)) | |||
497 | return true; | |||
498 | ||||
499 | if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) { | |||
500 | if (CheckAvailability(getASTContext(), Availability, | |||
501 | nullptr) == AR_NotYetIntroduced) | |||
502 | return true; | |||
503 | } | |||
504 | } | |||
505 | ||||
506 | return false; | |||
507 | } | |||
508 | ||||
509 | unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) { | |||
510 | switch (DeclKind) { | |||
511 | case Function: | |||
512 | case CXXMethod: | |||
513 | case CXXConstructor: | |||
514 | case CXXDestructor: | |||
515 | case CXXConversion: | |||
516 | case EnumConstant: | |||
517 | case Var: | |||
518 | case ImplicitParam: | |||
519 | case ParmVar: | |||
520 | case NonTypeTemplateParm: | |||
521 | case ObjCMethod: | |||
522 | case ObjCProperty: | |||
523 | case MSProperty: | |||
524 | return IDNS_Ordinary; | |||
525 | case Label: | |||
526 | return IDNS_Label; | |||
527 | case IndirectField: | |||
528 | return IDNS_Ordinary | IDNS_Member; | |||
529 | ||||
530 | case ObjCCompatibleAlias: | |||
531 | case ObjCInterface: | |||
532 | return IDNS_Ordinary | IDNS_Type; | |||
533 | ||||
534 | case Typedef: | |||
535 | case TypeAlias: | |||
536 | case TypeAliasTemplate: | |||
537 | case UnresolvedUsingTypename: | |||
538 | case TemplateTypeParm: | |||
539 | return IDNS_Ordinary | IDNS_Type; | |||
540 | ||||
541 | case UsingShadow: | |||
542 | return 0; // we'll actually overwrite this later | |||
543 | ||||
544 | case UnresolvedUsingValue: | |||
545 | return IDNS_Ordinary | IDNS_Using; | |||
546 | ||||
547 | case Using: | |||
548 | return IDNS_Using; | |||
549 | ||||
550 | case ObjCProtocol: | |||
551 | return IDNS_ObjCProtocol; | |||
552 | ||||
553 | case Field: | |||
554 | case ObjCAtDefsField: | |||
555 | case ObjCIvar: | |||
556 | return IDNS_Member; | |||
557 | ||||
558 | case Record: | |||
559 | case CXXRecord: | |||
560 | case Enum: | |||
561 | return IDNS_Tag | IDNS_Type; | |||
562 | ||||
563 | case Namespace: | |||
564 | case NamespaceAlias: | |||
565 | return IDNS_Namespace; | |||
566 | ||||
567 | case FunctionTemplate: | |||
568 | case VarTemplate: | |||
569 | return IDNS_Ordinary; | |||
570 | ||||
571 | case ClassTemplate: | |||
572 | case TemplateTemplateParm: | |||
573 | return IDNS_Ordinary | IDNS_Tag | IDNS_Type; | |||
574 | ||||
575 | // Never have names. | |||
576 | case Friend: | |||
577 | case FriendTemplate: | |||
578 | case AccessSpec: | |||
579 | case LinkageSpec: | |||
580 | case FileScopeAsm: | |||
581 | case StaticAssert: | |||
582 | case ObjCPropertyImpl: | |||
583 | case Block: | |||
584 | case Captured: | |||
585 | case TranslationUnit: | |||
586 | ||||
587 | case UsingDirective: | |||
588 | case ClassTemplateSpecialization: | |||
589 | case ClassTemplatePartialSpecialization: | |||
590 | case ClassScopeFunctionSpecialization: | |||
591 | case VarTemplateSpecialization: | |||
592 | case VarTemplatePartialSpecialization: | |||
593 | case ObjCImplementation: | |||
594 | case ObjCCategory: | |||
595 | case ObjCCategoryImpl: | |||
596 | case Import: | |||
597 | case OMPThreadPrivate: | |||
598 | case Empty: | |||
599 | // Never looked up by name. | |||
600 | return 0; | |||
601 | } | |||
602 | ||||
603 | llvm_unreachable("Invalid DeclKind!")::llvm::llvm_unreachable_internal("Invalid DeclKind!", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 603); | |||
604 | } | |||
605 | ||||
606 | void Decl::setAttrsImpl(const AttrVec &attrs, ASTContext &Ctx) { | |||
607 | assert(!HasAttrs && "Decl already contains attrs.")((!HasAttrs && "Decl already contains attrs.") ? static_cast <void> (0) : __assert_fail ("!HasAttrs && \"Decl already contains attrs.\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 607, __PRETTY_FUNCTION__)); | |||
608 | ||||
609 | AttrVec &AttrBlank = Ctx.getDeclAttrs(this); | |||
610 | assert(AttrBlank.empty() && "HasAttrs was wrong?")((AttrBlank.empty() && "HasAttrs was wrong?") ? static_cast <void> (0) : __assert_fail ("AttrBlank.empty() && \"HasAttrs was wrong?\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 610, __PRETTY_FUNCTION__)); | |||
611 | ||||
612 | AttrBlank = attrs; | |||
613 | HasAttrs = true; | |||
614 | } | |||
615 | ||||
616 | void Decl::dropAttrs() { | |||
617 | if (!HasAttrs) return; | |||
618 | ||||
619 | HasAttrs = false; | |||
620 | getASTContext().eraseDeclAttrs(this); | |||
621 | } | |||
622 | ||||
623 | const AttrVec &Decl::getAttrs() const { | |||
624 | assert(HasAttrs && "No attrs to get!")((HasAttrs && "No attrs to get!") ? static_cast<void > (0) : __assert_fail ("HasAttrs && \"No attrs to get!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 624, __PRETTY_FUNCTION__)); | |||
625 | return getASTContext().getDeclAttrs(this); | |||
626 | } | |||
627 | ||||
628 | Decl *Decl::castFromDeclContext (const DeclContext *D) { | |||
629 | Decl::Kind DK = D->getDeclKind(); | |||
630 | switch(DK) { | |||
631 | #define DECL(NAME, BASE) | |||
632 | #define DECL_CONTEXT(NAME) \ | |||
633 | case Decl::NAME: \ | |||
634 | return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D)); | |||
635 | #define DECL_CONTEXT_BASE(NAME) | |||
636 | #include "clang/AST/DeclNodes.inc" | |||
637 | default: | |||
638 | #define DECL(NAME, BASE) | |||
639 | #define DECL_CONTEXT_BASE(NAME) \ | |||
640 | if (DK >= first##NAME && DK <= last##NAME) \ | |||
641 | return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D)); | |||
642 | #include "clang/AST/DeclNodes.inc" | |||
643 | llvm_unreachable("a decl that inherits DeclContext isn't handled")::llvm::llvm_unreachable_internal("a decl that inherits DeclContext isn't handled" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 643); | |||
644 | } | |||
645 | } | |||
646 | ||||
647 | DeclContext *Decl::castToDeclContext(const Decl *D) { | |||
648 | Decl::Kind DK = D->getKind(); | |||
649 | switch(DK) { | |||
650 | #define DECL(NAME, BASE) | |||
651 | #define DECL_CONTEXT(NAME) \ | |||
652 | case Decl::NAME: \ | |||
653 | return static_cast<NAME##Decl*>(const_cast<Decl*>(D)); | |||
654 | #define DECL_CONTEXT_BASE(NAME) | |||
655 | #include "clang/AST/DeclNodes.inc" | |||
656 | default: | |||
657 | #define DECL(NAME, BASE) | |||
658 | #define DECL_CONTEXT_BASE(NAME) \ | |||
659 | if (DK >= first##NAME && DK <= last##NAME) \ | |||
660 | return static_cast<NAME##Decl*>(const_cast<Decl*>(D)); | |||
661 | #include "clang/AST/DeclNodes.inc" | |||
662 | llvm_unreachable("a decl that inherits DeclContext isn't handled")::llvm::llvm_unreachable_internal("a decl that inherits DeclContext isn't handled" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 662); | |||
663 | } | |||
664 | } | |||
665 | ||||
666 | SourceLocation Decl::getBodyRBrace() const { | |||
667 | // Special handling of FunctionDecl to avoid de-serializing the body from PCH. | |||
668 | // FunctionDecl stores EndRangeLoc for this purpose. | |||
669 | if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) { | |||
670 | const FunctionDecl *Definition; | |||
671 | if (FD->hasBody(Definition)) | |||
672 | return Definition->getSourceRange().getEnd(); | |||
673 | return SourceLocation(); | |||
674 | } | |||
675 | ||||
676 | if (Stmt *Body = getBody()) | |||
677 | return Body->getSourceRange().getEnd(); | |||
678 | ||||
679 | return SourceLocation(); | |||
680 | } | |||
681 | ||||
682 | bool Decl::AccessDeclContextSanity() const { | |||
683 | #ifndef NDEBUG | |||
684 | // Suppress this check if any of the following hold: | |||
685 | // 1. this is the translation unit (and thus has no parent) | |||
686 | // 2. this is a template parameter (and thus doesn't belong to its context) | |||
687 | // 3. this is a non-type template parameter | |||
688 | // 4. the context is not a record | |||
689 | // 5. it's invalid | |||
690 | // 6. it's a C++0x static_assert. | |||
691 | if (isa<TranslationUnitDecl>(this) || | |||
692 | isa<TemplateTypeParmDecl>(this) || | |||
693 | isa<NonTypeTemplateParmDecl>(this) || | |||
694 | !isa<CXXRecordDecl>(getDeclContext()) || | |||
695 | isInvalidDecl() || | |||
696 | isa<StaticAssertDecl>(this) || | |||
697 | // FIXME: a ParmVarDecl can have ClassTemplateSpecialization | |||
698 | // as DeclContext (?). | |||
699 | isa<ParmVarDecl>(this) || | |||
700 | // FIXME: a ClassTemplateSpecialization or CXXRecordDecl can have | |||
701 | // AS_none as access specifier. | |||
702 | isa<CXXRecordDecl>(this) || | |||
703 | isa<ClassScopeFunctionSpecializationDecl>(this)) | |||
704 | return true; | |||
705 | ||||
706 | assert(Access != AS_none &&((Access != AS_none && "Access specifier is AS_none inside a record decl" ) ? static_cast<void> (0) : __assert_fail ("Access != AS_none && \"Access specifier is AS_none inside a record decl\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 707, __PRETTY_FUNCTION__)) | |||
707 | "Access specifier is AS_none inside a record decl")((Access != AS_none && "Access specifier is AS_none inside a record decl" ) ? static_cast<void> (0) : __assert_fail ("Access != AS_none && \"Access specifier is AS_none inside a record decl\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 707, __PRETTY_FUNCTION__)); | |||
708 | #endif | |||
709 | return true; | |||
710 | } | |||
711 | ||||
712 | static Decl::Kind getKind(const Decl *D) { return D->getKind(); } | |||
713 | static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); } | |||
714 | ||||
715 | const FunctionType *Decl::getFunctionType(bool BlocksToo) const { | |||
716 | QualType Ty; | |||
717 | if (const ValueDecl *D = dyn_cast<ValueDecl>(this)) | |||
718 | Ty = D->getType(); | |||
719 | else if (const TypedefNameDecl *D = dyn_cast<TypedefNameDecl>(this)) | |||
720 | Ty = D->getUnderlyingType(); | |||
721 | else | |||
722 | return nullptr; | |||
723 | ||||
724 | if (Ty->isFunctionPointerType()) | |||
725 | Ty = Ty->getAs<PointerType>()->getPointeeType(); | |||
726 | else if (BlocksToo && Ty->isBlockPointerType()) | |||
727 | Ty = Ty->getAs<BlockPointerType>()->getPointeeType(); | |||
728 | ||||
729 | return Ty->getAs<FunctionType>(); | |||
730 | } | |||
731 | ||||
732 | ||||
733 | /// Starting at a given context (a Decl or DeclContext), look for a | |||
734 | /// code context that is not a closure (a lambda, block, etc.). | |||
735 | template <class T> static Decl *getNonClosureContext(T *D) { | |||
736 | if (getKind(D) == Decl::CXXMethod) { | |||
737 | CXXMethodDecl *MD = cast<CXXMethodDecl>(D); | |||
738 | if (MD->getOverloadedOperator() == OO_Call && | |||
739 | MD->getParent()->isLambda()) | |||
740 | return getNonClosureContext(MD->getParent()->getParent()); | |||
741 | return MD; | |||
742 | } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { | |||
743 | return FD; | |||
744 | } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { | |||
745 | return MD; | |||
746 | } else if (BlockDecl *BD = dyn_cast<BlockDecl>(D)) { | |||
747 | return getNonClosureContext(BD->getParent()); | |||
748 | } else if (CapturedDecl *CD = dyn_cast<CapturedDecl>(D)) { | |||
749 | return getNonClosureContext(CD->getParent()); | |||
750 | } else { | |||
751 | return nullptr; | |||
752 | } | |||
753 | } | |||
754 | ||||
755 | Decl *Decl::getNonClosureContext() { | |||
756 | return ::getNonClosureContext(this); | |||
757 | } | |||
758 | ||||
759 | Decl *DeclContext::getNonClosureAncestor() { | |||
760 | return ::getNonClosureContext(this); | |||
761 | } | |||
762 | ||||
763 | //===----------------------------------------------------------------------===// | |||
764 | // DeclContext Implementation | |||
765 | //===----------------------------------------------------------------------===// | |||
766 | ||||
767 | bool DeclContext::classof(const Decl *D) { | |||
768 | switch (D->getKind()) { | |||
769 | #define DECL(NAME, BASE) | |||
770 | #define DECL_CONTEXT(NAME) case Decl::NAME: | |||
771 | #define DECL_CONTEXT_BASE(NAME) | |||
772 | #include "clang/AST/DeclNodes.inc" | |||
773 | return true; | |||
774 | default: | |||
775 | #define DECL(NAME, BASE) | |||
776 | #define DECL_CONTEXT_BASE(NAME) \ | |||
777 | if (D->getKind() >= Decl::first##NAME && \ | |||
778 | D->getKind() <= Decl::last##NAME) \ | |||
779 | return true; | |||
780 | #include "clang/AST/DeclNodes.inc" | |||
781 | return false; | |||
782 | } | |||
783 | } | |||
784 | ||||
785 | DeclContext::~DeclContext() { } | |||
786 | ||||
787 | /// \brief Find the parent context of this context that will be | |||
788 | /// used for unqualified name lookup. | |||
789 | /// | |||
790 | /// Generally, the parent lookup context is the semantic context. However, for | |||
791 | /// a friend function the parent lookup context is the lexical context, which | |||
792 | /// is the class in which the friend is declared. | |||
793 | DeclContext *DeclContext::getLookupParent() { | |||
794 | // FIXME: Find a better way to identify friends | |||
795 | if (isa<FunctionDecl>(this)) | |||
796 | if (getParent()->getRedeclContext()->isFileContext() && | |||
797 | getLexicalParent()->getRedeclContext()->isRecord()) | |||
798 | return getLexicalParent(); | |||
799 | ||||
800 | return getParent(); | |||
801 | } | |||
802 | ||||
803 | bool DeclContext::isInlineNamespace() const { | |||
804 | return isNamespace() && | |||
805 | cast<NamespaceDecl>(this)->isInline(); | |||
806 | } | |||
807 | ||||
808 | bool DeclContext::isStdNamespace() const { | |||
809 | if (!isNamespace()) | |||
810 | return false; | |||
811 | ||||
812 | const NamespaceDecl *ND = cast<NamespaceDecl>(this); | |||
813 | if (ND->isInline()) { | |||
814 | return ND->getParent()->isStdNamespace(); | |||
815 | } | |||
816 | ||||
817 | if (!getParent()->getRedeclContext()->isTranslationUnit()) | |||
818 | return false; | |||
819 | ||||
820 | const IdentifierInfo *II = ND->getIdentifier(); | |||
821 | return II && II->isStr("std"); | |||
822 | } | |||
823 | ||||
824 | bool DeclContext::isDependentContext() const { | |||
825 | if (isFileContext()) | |||
826 | return false; | |||
827 | ||||
828 | if (isa<ClassTemplatePartialSpecializationDecl>(this)) | |||
829 | return true; | |||
830 | ||||
831 | if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this)) { | |||
832 | if (Record->getDescribedClassTemplate()) | |||
833 | return true; | |||
834 | ||||
835 | if (Record->isDependentLambda()) | |||
836 | return true; | |||
837 | } | |||
838 | ||||
839 | if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(this)) { | |||
840 | if (Function->getDescribedFunctionTemplate()) | |||
841 | return true; | |||
842 | ||||
843 | // Friend function declarations are dependent if their *lexical* | |||
844 | // context is dependent. | |||
845 | if (cast<Decl>(this)->getFriendObjectKind()) | |||
846 | return getLexicalParent()->isDependentContext(); | |||
847 | } | |||
848 | ||||
849 | return getParent() && getParent()->isDependentContext(); | |||
850 | } | |||
851 | ||||
852 | bool DeclContext::isTransparentContext() const { | |||
853 | if (DeclKind == Decl::Enum) | |||
854 | return !cast<EnumDecl>(this)->isScoped(); | |||
855 | else if (DeclKind == Decl::LinkageSpec) | |||
856 | return true; | |||
857 | ||||
858 | return false; | |||
859 | } | |||
860 | ||||
861 | static bool isLinkageSpecContext(const DeclContext *DC, | |||
862 | LinkageSpecDecl::LanguageIDs ID) { | |||
863 | while (DC->getDeclKind() != Decl::TranslationUnit) { | |||
864 | if (DC->getDeclKind() == Decl::LinkageSpec) | |||
865 | return cast<LinkageSpecDecl>(DC)->getLanguage() == ID; | |||
866 | DC = DC->getLexicalParent(); | |||
867 | } | |||
868 | return false; | |||
869 | } | |||
870 | ||||
871 | bool DeclContext::isExternCContext() const { | |||
872 | return isLinkageSpecContext(this, clang::LinkageSpecDecl::lang_c); | |||
873 | } | |||
874 | ||||
875 | bool DeclContext::isExternCXXContext() const { | |||
876 | return isLinkageSpecContext(this, clang::LinkageSpecDecl::lang_cxx); | |||
877 | } | |||
878 | ||||
879 | bool DeclContext::Encloses(const DeclContext *DC) const { | |||
880 | if (getPrimaryContext() != this) | |||
881 | return getPrimaryContext()->Encloses(DC); | |||
882 | ||||
883 | for (; DC; DC = DC->getParent()) | |||
884 | if (DC->getPrimaryContext() == this) | |||
885 | return true; | |||
886 | return false; | |||
887 | } | |||
888 | ||||
889 | DeclContext *DeclContext::getPrimaryContext() { | |||
890 | switch (DeclKind) { | |||
891 | case Decl::TranslationUnit: | |||
892 | case Decl::LinkageSpec: | |||
893 | case Decl::Block: | |||
894 | case Decl::Captured: | |||
895 | // There is only one DeclContext for these entities. | |||
896 | return this; | |||
897 | ||||
898 | case Decl::Namespace: | |||
899 | // The original namespace is our primary context. | |||
900 | return static_cast<NamespaceDecl*>(this)->getOriginalNamespace(); | |||
901 | ||||
902 | case Decl::ObjCMethod: | |||
903 | return this; | |||
904 | ||||
905 | case Decl::ObjCInterface: | |||
906 | if (ObjCInterfaceDecl *Def = cast<ObjCInterfaceDecl>(this)->getDefinition()) | |||
907 | return Def; | |||
908 | ||||
909 | return this; | |||
910 | ||||
911 | case Decl::ObjCProtocol: | |||
912 | if (ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(this)->getDefinition()) | |||
913 | return Def; | |||
914 | ||||
915 | return this; | |||
916 | ||||
917 | case Decl::ObjCCategory: | |||
918 | return this; | |||
919 | ||||
920 | case Decl::ObjCImplementation: | |||
921 | case Decl::ObjCCategoryImpl: | |||
922 | return this; | |||
923 | ||||
924 | default: | |||
925 | if (DeclKind >= Decl::firstTag && DeclKind <= Decl::lastTag) { | |||
926 | // If this is a tag type that has a definition or is currently | |||
927 | // being defined, that definition is our primary context. | |||
928 | TagDecl *Tag = cast<TagDecl>(this); | |||
929 | ||||
930 | if (TagDecl *Def = Tag->getDefinition()) | |||
931 | return Def; | |||
932 | ||||
933 | if (const TagType *TagTy = dyn_cast<TagType>(Tag->getTypeForDecl())) { | |||
934 | // Note, TagType::getDecl returns the (partial) definition one exists. | |||
935 | TagDecl *PossiblePartialDef = TagTy->getDecl(); | |||
936 | if (PossiblePartialDef->isBeingDefined()) | |||
937 | return PossiblePartialDef; | |||
938 | } else { | |||
939 | assert(isa<InjectedClassNameType>(Tag->getTypeForDecl()))((isa<InjectedClassNameType>(Tag->getTypeForDecl())) ? static_cast<void> (0) : __assert_fail ("isa<InjectedClassNameType>(Tag->getTypeForDecl())" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 939, __PRETTY_FUNCTION__)); | |||
940 | } | |||
941 | ||||
942 | return Tag; | |||
943 | } | |||
944 | ||||
945 | assert(DeclKind >= Decl::firstFunction && DeclKind <= Decl::lastFunction &&((DeclKind >= Decl::firstFunction && DeclKind <= Decl::lastFunction && "Unknown DeclContext kind") ? static_cast <void> (0) : __assert_fail ("DeclKind >= Decl::firstFunction && DeclKind <= Decl::lastFunction && \"Unknown DeclContext kind\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 946, __PRETTY_FUNCTION__)) | |||
946 | "Unknown DeclContext kind")((DeclKind >= Decl::firstFunction && DeclKind <= Decl::lastFunction && "Unknown DeclContext kind") ? static_cast <void> (0) : __assert_fail ("DeclKind >= Decl::firstFunction && DeclKind <= Decl::lastFunction && \"Unknown DeclContext kind\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 946, __PRETTY_FUNCTION__)); | |||
947 | return this; | |||
948 | } | |||
949 | } | |||
950 | ||||
951 | void | |||
952 | DeclContext::collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts){ | |||
953 | Contexts.clear(); | |||
954 | ||||
955 | if (DeclKind != Decl::Namespace) { | |||
956 | Contexts.push_back(this); | |||
957 | return; | |||
958 | } | |||
959 | ||||
960 | NamespaceDecl *Self = static_cast<NamespaceDecl *>(this); | |||
961 | for (NamespaceDecl *N = Self->getMostRecentDecl(); N; | |||
962 | N = N->getPreviousDecl()) | |||
963 | Contexts.push_back(N); | |||
964 | ||||
965 | std::reverse(Contexts.begin(), Contexts.end()); | |||
966 | } | |||
967 | ||||
968 | std::pair<Decl *, Decl *> | |||
969 | DeclContext::BuildDeclChain(ArrayRef<Decl*> Decls, | |||
970 | bool FieldsAlreadyLoaded) { | |||
971 | // Build up a chain of declarations via the Decl::NextInContextAndBits field. | |||
972 | Decl *FirstNewDecl = nullptr; | |||
973 | Decl *PrevDecl = nullptr; | |||
974 | for (unsigned I = 0, N = Decls.size(); I != N; ++I) { | |||
975 | if (FieldsAlreadyLoaded && isa<FieldDecl>(Decls[I])) | |||
976 | continue; | |||
977 | ||||
978 | Decl *D = Decls[I]; | |||
979 | if (PrevDecl) | |||
980 | PrevDecl->NextInContextAndBits.setPointer(D); | |||
981 | else | |||
982 | FirstNewDecl = D; | |||
983 | ||||
984 | PrevDecl = D; | |||
985 | } | |||
986 | ||||
987 | return std::make_pair(FirstNewDecl, PrevDecl); | |||
988 | } | |||
989 | ||||
990 | /// \brief We have just acquired external visible storage, and we already have | |||
991 | /// built a lookup map. For every name in the map, pull in the new names from | |||
992 | /// the external storage. | |||
993 | void DeclContext::reconcileExternalVisibleStorage() const { | |||
994 | assert(NeedToReconcileExternalVisibleStorage && LookupPtr.getPointer())((NeedToReconcileExternalVisibleStorage && LookupPtr. getPointer()) ? static_cast<void> (0) : __assert_fail ( "NeedToReconcileExternalVisibleStorage && LookupPtr.getPointer()" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 994, __PRETTY_FUNCTION__)); | |||
995 | NeedToReconcileExternalVisibleStorage = false; | |||
996 | ||||
997 | for (auto &Lookup : *LookupPtr.getPointer()) | |||
998 | Lookup.second.setHasExternalDecls(); | |||
999 | } | |||
1000 | ||||
1001 | /// \brief Load the declarations within this lexical storage from an | |||
1002 | /// external source. | |||
1003 | void | |||
1004 | DeclContext::LoadLexicalDeclsFromExternalStorage() const { | |||
1005 | ExternalASTSource *Source = getParentASTContext().getExternalSource(); | |||
1006 | assert(hasExternalLexicalStorage() && Source && "No external storage?")((hasExternalLexicalStorage() && Source && "No external storage?" ) ? static_cast<void> (0) : __assert_fail ("hasExternalLexicalStorage() && Source && \"No external storage?\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1006, __PRETTY_FUNCTION__)); | |||
1007 | ||||
1008 | // Notify that we have a DeclContext that is initializing. | |||
1009 | ExternalASTSource::Deserializing ADeclContext(Source); | |||
1010 | ||||
1011 | // Load the external declarations, if any. | |||
1012 | SmallVector<Decl*, 64> Decls; | |||
1013 | ExternalLexicalStorage = false; | |||
1014 | switch (Source->FindExternalLexicalDecls(this, Decls)) { | |||
1015 | case ELR_Success: | |||
1016 | break; | |||
1017 | ||||
1018 | case ELR_Failure: | |||
1019 | case ELR_AlreadyLoaded: | |||
1020 | return; | |||
1021 | } | |||
1022 | ||||
1023 | if (Decls.empty()) | |||
1024 | return; | |||
1025 | ||||
1026 | // We may have already loaded just the fields of this record, in which case | |||
1027 | // we need to ignore them. | |||
1028 | bool FieldsAlreadyLoaded = false; | |||
1029 | if (const RecordDecl *RD = dyn_cast<RecordDecl>(this)) | |||
1030 | FieldsAlreadyLoaded = RD->LoadedFieldsFromExternalStorage; | |||
1031 | ||||
1032 | // Splice the newly-read declarations into the beginning of the list | |||
1033 | // of declarations. | |||
1034 | Decl *ExternalFirst, *ExternalLast; | |||
1035 | std::tie(ExternalFirst, ExternalLast) = | |||
1036 | BuildDeclChain(Decls, FieldsAlreadyLoaded); | |||
1037 | ExternalLast->NextInContextAndBits.setPointer(FirstDecl); | |||
1038 | FirstDecl = ExternalFirst; | |||
1039 | if (!LastDecl) | |||
1040 | LastDecl = ExternalLast; | |||
1041 | } | |||
1042 | ||||
1043 | DeclContext::lookup_result | |||
1044 | ExternalASTSource::SetNoExternalVisibleDeclsForName(const DeclContext *DC, | |||
1045 | DeclarationName Name) { | |||
1046 | ASTContext &Context = DC->getParentASTContext(); | |||
1047 | StoredDeclsMap *Map; | |||
1048 | if (!(Map = DC->LookupPtr.getPointer())) | |||
1049 | Map = DC->CreateStoredDeclsMap(Context); | |||
1050 | if (DC->NeedToReconcileExternalVisibleStorage) | |||
1051 | DC->reconcileExternalVisibleStorage(); | |||
1052 | ||||
1053 | (*Map)[Name].removeExternalDecls(); | |||
1054 | ||||
1055 | return DeclContext::lookup_result(); | |||
1056 | } | |||
1057 | ||||
1058 | DeclContext::lookup_result | |||
1059 | ExternalASTSource::SetExternalVisibleDeclsForName(const DeclContext *DC, | |||
1060 | DeclarationName Name, | |||
1061 | ArrayRef<NamedDecl*> Decls) { | |||
1062 | ASTContext &Context = DC->getParentASTContext(); | |||
1063 | StoredDeclsMap *Map; | |||
1064 | if (!(Map = DC->LookupPtr.getPointer())) | |||
1065 | Map = DC->CreateStoredDeclsMap(Context); | |||
1066 | if (DC->NeedToReconcileExternalVisibleStorage) | |||
1067 | DC->reconcileExternalVisibleStorage(); | |||
1068 | ||||
1069 | StoredDeclsList &List = (*Map)[Name]; | |||
1070 | ||||
1071 | // Clear out any old external visible declarations, to avoid quadratic | |||
1072 | // performance in the redeclaration checks below. | |||
1073 | List.removeExternalDecls(); | |||
1074 | ||||
1075 | if (!List.isNull()) { | |||
1076 | // We have both existing declarations and new declarations for this name. | |||
1077 | // Some of the declarations may simply replace existing ones. Handle those | |||
1078 | // first. | |||
1079 | llvm::SmallVector<unsigned, 8> Skip; | |||
1080 | for (unsigned I = 0, N = Decls.size(); I != N; ++I) | |||
1081 | if (List.HandleRedeclaration(Decls[I])) | |||
1082 | Skip.push_back(I); | |||
1083 | Skip.push_back(Decls.size()); | |||
1084 | ||||
1085 | // Add in any new declarations. | |||
1086 | unsigned SkipPos = 0; | |||
1087 | for (unsigned I = 0, N = Decls.size(); I != N; ++I) { | |||
1088 | if (I == Skip[SkipPos]) | |||
1089 | ++SkipPos; | |||
1090 | else | |||
1091 | List.AddSubsequentDecl(Decls[I]); | |||
1092 | } | |||
1093 | } else { | |||
1094 | // Convert the array to a StoredDeclsList. | |||
1095 | for (ArrayRef<NamedDecl*>::iterator | |||
1096 | I = Decls.begin(), E = Decls.end(); I != E; ++I) { | |||
1097 | if (List.isNull()) | |||
1098 | List.setOnlyValue(*I); | |||
1099 | else | |||
1100 | List.AddSubsequentDecl(*I); | |||
1101 | } | |||
1102 | } | |||
1103 | ||||
1104 | return List.getLookupResult(); | |||
1105 | } | |||
1106 | ||||
1107 | DeclContext::decl_iterator DeclContext::decls_begin() const { | |||
1108 | if (hasExternalLexicalStorage()) | |||
1109 | LoadLexicalDeclsFromExternalStorage(); | |||
1110 | return decl_iterator(FirstDecl); | |||
1111 | } | |||
1112 | ||||
1113 | bool DeclContext::decls_empty() const { | |||
1114 | if (hasExternalLexicalStorage()) | |||
1115 | LoadLexicalDeclsFromExternalStorage(); | |||
1116 | ||||
1117 | return !FirstDecl; | |||
1118 | } | |||
1119 | ||||
1120 | bool DeclContext::containsDecl(Decl *D) const { | |||
1121 | return (D->getLexicalDeclContext() == this && | |||
1122 | (D->NextInContextAndBits.getPointer() || D == LastDecl)); | |||
1123 | } | |||
1124 | ||||
1125 | void DeclContext::removeDecl(Decl *D) { | |||
1126 | assert(D->getLexicalDeclContext() == this &&((D->getLexicalDeclContext() == this && "decl being removed from non-lexical context" ) ? static_cast<void> (0) : __assert_fail ("D->getLexicalDeclContext() == this && \"decl being removed from non-lexical context\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1127, __PRETTY_FUNCTION__)) | |||
1127 | "decl being removed from non-lexical context")((D->getLexicalDeclContext() == this && "decl being removed from non-lexical context" ) ? static_cast<void> (0) : __assert_fail ("D->getLexicalDeclContext() == this && \"decl being removed from non-lexical context\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1127, __PRETTY_FUNCTION__)); | |||
1128 | assert((D->NextInContextAndBits.getPointer() || D == LastDecl) &&(((D->NextInContextAndBits.getPointer() || D == LastDecl) && "decl is not in decls list") ? static_cast<void> (0) : __assert_fail ("(D->NextInContextAndBits.getPointer() || D == LastDecl) && \"decl is not in decls list\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1129, __PRETTY_FUNCTION__)) | |||
1129 | "decl is not in decls list")(((D->NextInContextAndBits.getPointer() || D == LastDecl) && "decl is not in decls list") ? static_cast<void> (0) : __assert_fail ("(D->NextInContextAndBits.getPointer() || D == LastDecl) && \"decl is not in decls list\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1129, __PRETTY_FUNCTION__)); | |||
1130 | ||||
1131 | // Remove D from the decl chain. This is O(n) but hopefully rare. | |||
1132 | if (D == FirstDecl) { | |||
1133 | if (D == LastDecl) | |||
1134 | FirstDecl = LastDecl = nullptr; | |||
1135 | else | |||
1136 | FirstDecl = D->NextInContextAndBits.getPointer(); | |||
1137 | } else { | |||
1138 | for (Decl *I = FirstDecl; true; I = I->NextInContextAndBits.getPointer()) { | |||
1139 | assert(I && "decl not found in linked list")((I && "decl not found in linked list") ? static_cast <void> (0) : __assert_fail ("I && \"decl not found in linked list\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1139, __PRETTY_FUNCTION__)); | |||
1140 | if (I->NextInContextAndBits.getPointer() == D) { | |||
1141 | I->NextInContextAndBits.setPointer(D->NextInContextAndBits.getPointer()); | |||
1142 | if (D == LastDecl) LastDecl = I; | |||
1143 | break; | |||
1144 | } | |||
1145 | } | |||
1146 | } | |||
1147 | ||||
1148 | // Mark that D is no longer in the decl chain. | |||
1149 | D->NextInContextAndBits.setPointer(nullptr); | |||
1150 | ||||
1151 | // Remove D from the lookup table if necessary. | |||
1152 | if (isa<NamedDecl>(D)) { | |||
1153 | NamedDecl *ND = cast<NamedDecl>(D); | |||
1154 | ||||
1155 | // Remove only decls that have a name | |||
1156 | if (!ND->getDeclName()) return; | |||
1157 | ||||
1158 | StoredDeclsMap *Map = getPrimaryContext()->LookupPtr.getPointer(); | |||
1159 | if (!Map) return; | |||
1160 | ||||
1161 | StoredDeclsMap::iterator Pos = Map->find(ND->getDeclName()); | |||
1162 | assert(Pos != Map->end() && "no lookup entry for decl")((Pos != Map->end() && "no lookup entry for decl") ? static_cast<void> (0) : __assert_fail ("Pos != Map->end() && \"no lookup entry for decl\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1162, __PRETTY_FUNCTION__)); | |||
1163 | if (Pos->second.getAsVector() || Pos->second.getAsDecl() == ND) | |||
1164 | Pos->second.remove(ND); | |||
1165 | } | |||
1166 | } | |||
1167 | ||||
1168 | void DeclContext::addHiddenDecl(Decl *D) { | |||
1169 | assert(D->getLexicalDeclContext() == this &&((D->getLexicalDeclContext() == this && "Decl inserted into wrong lexical context" ) ? static_cast<void> (0) : __assert_fail ("D->getLexicalDeclContext() == this && \"Decl inserted into wrong lexical context\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1170, __PRETTY_FUNCTION__)) | |||
1170 | "Decl inserted into wrong lexical context")((D->getLexicalDeclContext() == this && "Decl inserted into wrong lexical context" ) ? static_cast<void> (0) : __assert_fail ("D->getLexicalDeclContext() == this && \"Decl inserted into wrong lexical context\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1170, __PRETTY_FUNCTION__)); | |||
1171 | assert(!D->getNextDeclInContext() && D != LastDecl &&((!D->getNextDeclInContext() && D != LastDecl && "Decl already inserted into a DeclContext") ? static_cast< void> (0) : __assert_fail ("!D->getNextDeclInContext() && D != LastDecl && \"Decl already inserted into a DeclContext\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1172, __PRETTY_FUNCTION__)) | |||
1172 | "Decl already inserted into a DeclContext")((!D->getNextDeclInContext() && D != LastDecl && "Decl already inserted into a DeclContext") ? static_cast< void> (0) : __assert_fail ("!D->getNextDeclInContext() && D != LastDecl && \"Decl already inserted into a DeclContext\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1172, __PRETTY_FUNCTION__)); | |||
1173 | ||||
1174 | if (FirstDecl) { | |||
1175 | LastDecl->NextInContextAndBits.setPointer(D); | |||
1176 | LastDecl = D; | |||
1177 | } else { | |||
1178 | FirstDecl = LastDecl = D; | |||
1179 | } | |||
1180 | ||||
1181 | // Notify a C++ record declaration that we've added a member, so it can | |||
1182 | // update it's class-specific state. | |||
1183 | if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this)) | |||
1184 | Record->addedMember(D); | |||
1185 | ||||
1186 | // If this is a newly-created (not de-serialized) import declaration, wire | |||
1187 | // it in to the list of local import declarations. | |||
1188 | if (!D->isFromASTFile()) { | |||
1189 | if (ImportDecl *Import = dyn_cast<ImportDecl>(D)) | |||
1190 | D->getASTContext().addedLocalImportDecl(Import); | |||
1191 | } | |||
1192 | } | |||
1193 | ||||
1194 | void DeclContext::addDecl(Decl *D) { | |||
1195 | addHiddenDecl(D); | |||
1196 | ||||
1197 | if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) | |||
1198 | ND->getDeclContext()->getPrimaryContext()-> | |||
1199 | makeDeclVisibleInContextWithFlags(ND, false, true); | |||
1200 | } | |||
1201 | ||||
1202 | void DeclContext::addDeclInternal(Decl *D) { | |||
1203 | addHiddenDecl(D); | |||
1204 | ||||
1205 | if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) | |||
1206 | ND->getDeclContext()->getPrimaryContext()-> | |||
1207 | makeDeclVisibleInContextWithFlags(ND, true, true); | |||
1208 | } | |||
1209 | ||||
1210 | /// shouldBeHidden - Determine whether a declaration which was declared | |||
1211 | /// within its semantic context should be invisible to qualified name lookup. | |||
1212 | static bool shouldBeHidden(NamedDecl *D) { | |||
1213 | // Skip unnamed declarations. | |||
1214 | if (!D->getDeclName()) | |||
1215 | return true; | |||
1216 | ||||
1217 | // Skip entities that can't be found by name lookup into a particular | |||
1218 | // context. | |||
1219 | if ((D->getIdentifierNamespace() == 0 && !isa<UsingDirectiveDecl>(D)) || | |||
1220 | D->isTemplateParameter()) | |||
1221 | return true; | |||
1222 | ||||
1223 | // Skip template specializations. | |||
1224 | // FIXME: This feels like a hack. Should DeclarationName support | |||
1225 | // template-ids, or is there a better way to keep specializations | |||
1226 | // from being visible? | |||
1227 | if (isa<ClassTemplateSpecializationDecl>(D)) | |||
1228 | return true; | |||
1229 | if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) | |||
1230 | if (FD->isFunctionTemplateSpecialization()) | |||
1231 | return true; | |||
1232 | ||||
1233 | return false; | |||
1234 | } | |||
1235 | ||||
1236 | /// buildLookup - Build the lookup data structure with all of the | |||
1237 | /// declarations in this DeclContext (and any other contexts linked | |||
1238 | /// to it or transparent contexts nested within it) and return it. | |||
1239 | /// | |||
1240 | /// Note that the produced map may miss out declarations from an | |||
1241 | /// external source. If it does, those entries will be marked with | |||
1242 | /// the 'hasExternalDecls' flag. | |||
1243 | StoredDeclsMap *DeclContext::buildLookup() { | |||
1244 | assert(this == getPrimaryContext() && "buildLookup called on non-primary DC")((this == getPrimaryContext() && "buildLookup called on non-primary DC" ) ? static_cast<void> (0) : __assert_fail ("this == getPrimaryContext() && \"buildLookup called on non-primary DC\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1244, __PRETTY_FUNCTION__)); | |||
1245 | ||||
1246 | // FIXME: Should we keep going if hasExternalVisibleStorage? | |||
1247 | if (!LookupPtr.getInt()) | |||
1248 | return LookupPtr.getPointer(); | |||
1249 | ||||
1250 | SmallVector<DeclContext *, 2> Contexts; | |||
1251 | collectAllContexts(Contexts); | |||
1252 | for (unsigned I = 0, N = Contexts.size(); I != N; ++I) | |||
1253 | buildLookupImpl<&DeclContext::decls_begin, | |||
1254 | &DeclContext::decls_end>(Contexts[I]); | |||
1255 | ||||
1256 | // We no longer have any lazy decls. | |||
1257 | LookupPtr.setInt(false); | |||
1258 | return LookupPtr.getPointer(); | |||
1259 | } | |||
1260 | ||||
1261 | /// buildLookupImpl - Build part of the lookup data structure for the | |||
1262 | /// declarations contained within DCtx, which will either be this | |||
1263 | /// DeclContext, a DeclContext linked to it, or a transparent context | |||
1264 | /// nested within it. | |||
1265 | template<DeclContext::decl_iterator (DeclContext::*Begin)() const, | |||
1266 | DeclContext::decl_iterator (DeclContext::*End)() const> | |||
1267 | void DeclContext::buildLookupImpl(DeclContext *DCtx) { | |||
1268 | for (decl_iterator I = (DCtx->*Begin)(), E = (DCtx->*End)(); | |||
1269 | I != E; ++I) { | |||
1270 | Decl *D = *I; | |||
1271 | ||||
1272 | // Insert this declaration into the lookup structure, but only if | |||
1273 | // it's semantically within its decl context. Any other decls which | |||
1274 | // should be found in this context are added eagerly. | |||
1275 | // | |||
1276 | // If it's from an AST file, don't add it now. It'll get handled by | |||
1277 | // FindExternalVisibleDeclsByName if needed. Exception: if we're not | |||
1278 | // in C++, we do not track external visible decls for the TU, so in | |||
1279 | // that case we need to collect them all here. | |||
1280 | if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) | |||
1281 | if (ND->getDeclContext() == DCtx && !shouldBeHidden(ND) && | |||
1282 | (!ND->isFromASTFile() || | |||
1283 | (isTranslationUnit() && | |||
1284 | !getParentASTContext().getLangOpts().CPlusPlus))) | |||
1285 | makeDeclVisibleInContextImpl(ND, false); | |||
1286 | ||||
1287 | // If this declaration is itself a transparent declaration context | |||
1288 | // or inline namespace, add the members of this declaration of that | |||
1289 | // context (recursively). | |||
1290 | if (DeclContext *InnerCtx = dyn_cast<DeclContext>(D)) | |||
1291 | if (InnerCtx->isTransparentContext() || InnerCtx->isInlineNamespace()) | |||
1292 | buildLookupImpl<Begin, End>(InnerCtx); | |||
1293 | } | |||
1294 | } | |||
1295 | ||||
1296 | DeclContext::lookup_result | |||
1297 | DeclContext::lookup(DeclarationName Name) { | |||
1298 | assert(DeclKind != Decl::LinkageSpec &&((DeclKind != Decl::LinkageSpec && "Should not perform lookups into linkage specs!" ) ? static_cast<void> (0) : __assert_fail ("DeclKind != Decl::LinkageSpec && \"Should not perform lookups into linkage specs!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1299, __PRETTY_FUNCTION__)) | |||
1299 | "Should not perform lookups into linkage specs!")((DeclKind != Decl::LinkageSpec && "Should not perform lookups into linkage specs!" ) ? static_cast<void> (0) : __assert_fail ("DeclKind != Decl::LinkageSpec && \"Should not perform lookups into linkage specs!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1299, __PRETTY_FUNCTION__)); | |||
1300 | ||||
1301 | DeclContext *PrimaryContext = getPrimaryContext(); | |||
1302 | if (PrimaryContext != this) | |||
1303 | return PrimaryContext->lookup(Name); | |||
1304 | ||||
1305 | // If this is a namespace, ensure that any later redeclarations of it have | |||
1306 | // been loaded, since they may add names to the result of this lookup. | |||
1307 | if (auto *ND = dyn_cast<NamespaceDecl>(this)) | |||
1308 | (void)ND->getMostRecentDecl(); | |||
1309 | ||||
1310 | if (hasExternalVisibleStorage()) { | |||
1311 | if (NeedToReconcileExternalVisibleStorage) | |||
1312 | reconcileExternalVisibleStorage(); | |||
1313 | ||||
1314 | StoredDeclsMap *Map = LookupPtr.getPointer(); | |||
1315 | ||||
1316 | if (LookupPtr.getInt()) | |||
1317 | Map = buildLookup(); | |||
1318 | ||||
1319 | if (!Map) | |||
1320 | Map = CreateStoredDeclsMap(getParentASTContext()); | |||
1321 | ||||
1322 | // If we have a lookup result with no external decls, we are done. | |||
1323 | std::pair<StoredDeclsMap::iterator, bool> R = | |||
1324 | Map->insert(std::make_pair(Name, StoredDeclsList())); | |||
1325 | if (!R.second && !R.first->second.hasExternalDecls()) | |||
1326 | return R.first->second.getLookupResult(); | |||
1327 | ||||
1328 | ExternalASTSource *Source = getParentASTContext().getExternalSource(); | |||
1329 | if (Source->FindExternalVisibleDeclsByName(this, Name) || !R.second) { | |||
1330 | if (StoredDeclsMap *Map = LookupPtr.getPointer()) { | |||
1331 | StoredDeclsMap::iterator I = Map->find(Name); | |||
1332 | if (I != Map->end()) | |||
1333 | return I->second.getLookupResult(); | |||
1334 | } | |||
1335 | } | |||
1336 | ||||
1337 | return lookup_result(lookup_iterator(nullptr), lookup_iterator(nullptr)); | |||
1338 | } | |||
1339 | ||||
1340 | StoredDeclsMap *Map = LookupPtr.getPointer(); | |||
1341 | if (LookupPtr.getInt()) | |||
1342 | Map = buildLookup(); | |||
1343 | ||||
1344 | if (!Map) | |||
1345 | return lookup_result(lookup_iterator(nullptr), lookup_iterator(nullptr)); | |||
1346 | ||||
1347 | StoredDeclsMap::iterator I = Map->find(Name); | |||
1348 | if (I == Map->end()) | |||
1349 | return lookup_result(lookup_iterator(nullptr), lookup_iterator(nullptr)); | |||
1350 | ||||
1351 | return I->second.getLookupResult(); | |||
1352 | } | |||
1353 | ||||
1354 | DeclContext::lookup_result | |||
1355 | DeclContext::noload_lookup(DeclarationName Name) { | |||
1356 | assert(DeclKind != Decl::LinkageSpec &&((DeclKind != Decl::LinkageSpec && "Should not perform lookups into linkage specs!" ) ? static_cast<void> (0) : __assert_fail ("DeclKind != Decl::LinkageSpec && \"Should not perform lookups into linkage specs!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1357, __PRETTY_FUNCTION__)) | |||
1357 | "Should not perform lookups into linkage specs!")((DeclKind != Decl::LinkageSpec && "Should not perform lookups into linkage specs!" ) ? static_cast<void> (0) : __assert_fail ("DeclKind != Decl::LinkageSpec && \"Should not perform lookups into linkage specs!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1357, __PRETTY_FUNCTION__)); | |||
1358 | if (!hasExternalVisibleStorage()) | |||
1359 | return lookup(Name); | |||
1360 | ||||
1361 | DeclContext *PrimaryContext = getPrimaryContext(); | |||
1362 | if (PrimaryContext != this) | |||
1363 | return PrimaryContext->noload_lookup(Name); | |||
1364 | ||||
1365 | StoredDeclsMap *Map = LookupPtr.getPointer(); | |||
1366 | if (LookupPtr.getInt()) { | |||
1367 | // Carefully build the lookup map, without deserializing anything. | |||
1368 | SmallVector<DeclContext *, 2> Contexts; | |||
1369 | collectAllContexts(Contexts); | |||
1370 | for (unsigned I = 0, N = Contexts.size(); I != N; ++I) | |||
1371 | buildLookupImpl<&DeclContext::noload_decls_begin, | |||
1372 | &DeclContext::noload_decls_end>(Contexts[I]); | |||
1373 | ||||
1374 | // We no longer have any lazy decls. | |||
1375 | LookupPtr.setInt(false); | |||
1376 | ||||
1377 | // There may now be names for which we have local decls but are | |||
1378 | // missing the external decls. FIXME: Just set the hasExternalDecls | |||
1379 | // flag on those names that have external decls. | |||
1380 | NeedToReconcileExternalVisibleStorage = true; | |||
1381 | ||||
1382 | Map = LookupPtr.getPointer(); | |||
1383 | } | |||
1384 | ||||
1385 | if (!Map) | |||
1386 | return lookup_result(lookup_iterator(nullptr), lookup_iterator(nullptr)); | |||
1387 | ||||
1388 | StoredDeclsMap::iterator I = Map->find(Name); | |||
1389 | return I != Map->end() ? I->second.getLookupResult() | |||
1390 | : lookup_result(lookup_iterator(nullptr), | |||
1391 | lookup_iterator(nullptr)); | |||
1392 | } | |||
1393 | ||||
1394 | void DeclContext::localUncachedLookup(DeclarationName Name, | |||
1395 | SmallVectorImpl<NamedDecl *> &Results) { | |||
1396 | Results.clear(); | |||
1397 | ||||
1398 | // If there's no external storage, just perform a normal lookup and copy | |||
1399 | // the results. | |||
1400 | if (!hasExternalVisibleStorage() && !hasExternalLexicalStorage() && Name) { | |||
1401 | lookup_result LookupResults = lookup(Name); | |||
1402 | Results.insert(Results.end(), LookupResults.begin(), LookupResults.end()); | |||
1403 | return; | |||
1404 | } | |||
1405 | ||||
1406 | // If we have a lookup table, check there first. Maybe we'll get lucky. | |||
1407 | if (Name && !LookupPtr.getInt()) { | |||
1408 | if (StoredDeclsMap *Map = LookupPtr.getPointer()) { | |||
1409 | StoredDeclsMap::iterator Pos = Map->find(Name); | |||
1410 | if (Pos != Map->end()) { | |||
1411 | Results.insert(Results.end(), | |||
1412 | Pos->second.getLookupResult().begin(), | |||
1413 | Pos->second.getLookupResult().end()); | |||
1414 | return; | |||
1415 | } | |||
1416 | } | |||
1417 | } | |||
1418 | ||||
1419 | // Slow case: grovel through the declarations in our chain looking for | |||
1420 | // matches. | |||
1421 | for (Decl *D = FirstDecl; D; D = D->getNextDeclInContext()) { | |||
1422 | if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) | |||
1423 | if (ND->getDeclName() == Name) | |||
1424 | Results.push_back(ND); | |||
1425 | } | |||
1426 | } | |||
1427 | ||||
1428 | DeclContext *DeclContext::getRedeclContext() { | |||
1429 | DeclContext *Ctx = this; | |||
1430 | // Skip through transparent contexts. | |||
1431 | while (Ctx->isTransparentContext()) | |||
1432 | Ctx = Ctx->getParent(); | |||
1433 | return Ctx; | |||
1434 | } | |||
1435 | ||||
1436 | DeclContext *DeclContext::getEnclosingNamespaceContext() { | |||
1437 | DeclContext *Ctx = this; | |||
1438 | // Skip through non-namespace, non-translation-unit contexts. | |||
1439 | while (!Ctx->isFileContext()) | |||
1440 | Ctx = Ctx->getParent(); | |||
1441 | return Ctx->getPrimaryContext(); | |||
1442 | } | |||
1443 | ||||
1444 | RecordDecl *DeclContext::getOuterLexicalRecordContext() { | |||
1445 | // Loop until we find a non-record context. | |||
1446 | RecordDecl *OutermostRD = nullptr; | |||
1447 | DeclContext *DC = this; | |||
1448 | while (DC->isRecord()) { | |||
1449 | OutermostRD = cast<RecordDecl>(DC); | |||
1450 | DC = DC->getLexicalParent(); | |||
1451 | } | |||
1452 | return OutermostRD; | |||
1453 | } | |||
1454 | ||||
1455 | bool DeclContext::InEnclosingNamespaceSetOf(const DeclContext *O) const { | |||
1456 | // For non-file contexts, this is equivalent to Equals. | |||
1457 | if (!isFileContext()) | |||
1458 | return O->Equals(this); | |||
1459 | ||||
1460 | do { | |||
1461 | if (O->Equals(this)) | |||
1462 | return true; | |||
1463 | ||||
1464 | const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(O); | |||
1465 | if (!NS || !NS->isInline()) | |||
1466 | break; | |||
1467 | O = NS->getParent(); | |||
1468 | } while (O); | |||
1469 | ||||
1470 | return false; | |||
1471 | } | |||
1472 | ||||
1473 | void DeclContext::makeDeclVisibleInContext(NamedDecl *D) { | |||
1474 | DeclContext *PrimaryDC = this->getPrimaryContext(); | |||
1475 | DeclContext *DeclDC = D->getDeclContext()->getPrimaryContext(); | |||
1476 | // If the decl is being added outside of its semantic decl context, we | |||
1477 | // need to ensure that we eagerly build the lookup information for it. | |||
1478 | PrimaryDC->makeDeclVisibleInContextWithFlags(D, false, PrimaryDC == DeclDC); | |||
1479 | } | |||
1480 | ||||
1481 | void DeclContext::makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal, | |||
1482 | bool Recoverable) { | |||
1483 | assert(this == getPrimaryContext() && "expected a primary DC")((this == getPrimaryContext() && "expected a primary DC" ) ? static_cast<void> (0) : __assert_fail ("this == getPrimaryContext() && \"expected a primary DC\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1483, __PRETTY_FUNCTION__)); | |||
1484 | ||||
1485 | // Skip declarations within functions. | |||
1486 | if (isFunctionOrMethod()) | |||
1487 | return; | |||
1488 | ||||
1489 | // Skip declarations which should be invisible to name lookup. | |||
1490 | if (shouldBeHidden(D)) | |||
1491 | return; | |||
1492 | ||||
1493 | // If we already have a lookup data structure, perform the insertion into | |||
1494 | // it. If we might have externally-stored decls with this name, look them | |||
1495 | // up and perform the insertion. If this decl was declared outside its | |||
1496 | // semantic context, buildLookup won't add it, so add it now. | |||
1497 | // | |||
1498 | // FIXME: As a performance hack, don't add such decls into the translation | |||
1499 | // unit unless we're in C++, since qualified lookup into the TU is never | |||
1500 | // performed. | |||
1501 | if (LookupPtr.getPointer() || hasExternalVisibleStorage() || | |||
1502 | ((!Recoverable || D->getDeclContext() != D->getLexicalDeclContext()) && | |||
1503 | (getParentASTContext().getLangOpts().CPlusPlus || | |||
1504 | !isTranslationUnit()))) { | |||
1505 | // If we have lazily omitted any decls, they might have the same name as | |||
1506 | // the decl which we are adding, so build a full lookup table before adding | |||
1507 | // this decl. | |||
1508 | buildLookup(); | |||
1509 | makeDeclVisibleInContextImpl(D, Internal); | |||
1510 | } else { | |||
1511 | LookupPtr.setInt(true); | |||
1512 | } | |||
1513 | ||||
1514 | // If we are a transparent context or inline namespace, insert into our | |||
1515 | // parent context, too. This operation is recursive. | |||
1516 | if (isTransparentContext() || isInlineNamespace()) | |||
1517 | getParent()->getPrimaryContext()-> | |||
1518 | makeDeclVisibleInContextWithFlags(D, Internal, Recoverable); | |||
1519 | ||||
1520 | Decl *DCAsDecl = cast<Decl>(this); | |||
1521 | // Notify that a decl was made visible unless we are a Tag being defined. | |||
1522 | if (!(isa<TagDecl>(DCAsDecl) && cast<TagDecl>(DCAsDecl)->isBeingDefined())) | |||
1523 | if (ASTMutationListener *L = DCAsDecl->getASTMutationListener()) | |||
1524 | L->AddedVisibleDecl(this, D); | |||
1525 | } | |||
1526 | ||||
1527 | void DeclContext::makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal) { | |||
1528 | // Find or create the stored declaration map. | |||
1529 | StoredDeclsMap *Map = LookupPtr.getPointer(); | |||
1530 | if (!Map) { | |||
1531 | ASTContext *C = &getParentASTContext(); | |||
1532 | Map = CreateStoredDeclsMap(*C); | |||
1533 | } | |||
1534 | ||||
1535 | // If there is an external AST source, load any declarations it knows about | |||
1536 | // with this declaration's name. | |||
1537 | // If the lookup table contains an entry about this name it means that we | |||
1538 | // have already checked the external source. | |||
1539 | if (!Internal) | |||
1540 | if (ExternalASTSource *Source = getParentASTContext().getExternalSource()) | |||
1541 | if (hasExternalVisibleStorage() && | |||
1542 | Map->find(D->getDeclName()) == Map->end()) | |||
1543 | Source->FindExternalVisibleDeclsByName(this, D->getDeclName()); | |||
1544 | ||||
1545 | // Insert this declaration into the map. | |||
1546 | StoredDeclsList &DeclNameEntries = (*Map)[D->getDeclName()]; | |||
1547 | ||||
1548 | if (Internal) { | |||
1549 | // If this is being added as part of loading an external declaration, | |||
1550 | // this may not be the only external declaration with this name. | |||
1551 | // In this case, we never try to replace an existing declaration; we'll | |||
1552 | // handle that when we finalize the list of declarations for this name. | |||
1553 | DeclNameEntries.setHasExternalDecls(); | |||
1554 | DeclNameEntries.AddSubsequentDecl(D); | |||
1555 | return; | |||
1556 | } | |||
1557 | ||||
1558 | else if (DeclNameEntries.isNull()) { | |||
1559 | DeclNameEntries.setOnlyValue(D); | |||
1560 | return; | |||
1561 | } | |||
1562 | ||||
1563 | if (DeclNameEntries.HandleRedeclaration(D)) { | |||
1564 | // This declaration has replaced an existing one for which | |||
1565 | // declarationReplaces returns true. | |||
1566 | return; | |||
1567 | } | |||
1568 | ||||
1569 | // Put this declaration into the appropriate slot. | |||
1570 | DeclNameEntries.AddSubsequentDecl(D); | |||
1571 | } | |||
1572 | ||||
1573 | /// Returns iterator range [First, Last) of UsingDirectiveDecls stored within | |||
1574 | /// this context. | |||
1575 | DeclContext::udir_range DeclContext::using_directives() const { | |||
1576 | // FIXME: Use something more efficient than normal lookup for using | |||
1577 | // directives. In C++, using directives are looked up more than anything else. | |||
1578 | lookup_const_result Result = lookup(UsingDirectiveDecl::getName()); | |||
1579 | return udir_range( | |||
1580 | reinterpret_cast<UsingDirectiveDecl *const *>(Result.begin()), | |||
1581 | reinterpret_cast<UsingDirectiveDecl *const *>(Result.end())); | |||
1582 | } | |||
1583 | ||||
1584 | //===----------------------------------------------------------------------===// | |||
1585 | // Creation and Destruction of StoredDeclsMaps. // | |||
1586 | //===----------------------------------------------------------------------===// | |||
1587 | ||||
1588 | StoredDeclsMap *DeclContext::CreateStoredDeclsMap(ASTContext &C) const { | |||
1589 | assert(!LookupPtr.getPointer() && "context already has a decls map")((!LookupPtr.getPointer() && "context already has a decls map" ) ? static_cast<void> (0) : __assert_fail ("!LookupPtr.getPointer() && \"context already has a decls map\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1589, __PRETTY_FUNCTION__)); | |||
1590 | assert(getPrimaryContext() == this &&((getPrimaryContext() == this && "creating decls map on non-primary context" ) ? static_cast<void> (0) : __assert_fail ("getPrimaryContext() == this && \"creating decls map on non-primary context\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1591, __PRETTY_FUNCTION__)) | |||
1591 | "creating decls map on non-primary context")((getPrimaryContext() == this && "creating decls map on non-primary context" ) ? static_cast<void> (0) : __assert_fail ("getPrimaryContext() == this && \"creating decls map on non-primary context\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1591, __PRETTY_FUNCTION__)); | |||
1592 | ||||
1593 | StoredDeclsMap *M; | |||
1594 | bool Dependent = isDependentContext(); | |||
1595 | if (Dependent) | |||
1596 | M = new DependentStoredDeclsMap(); | |||
1597 | else | |||
1598 | M = new StoredDeclsMap(); | |||
1599 | M->Previous = C.LastSDM; | |||
1600 | C.LastSDM = llvm::PointerIntPair<StoredDeclsMap*,1>(M, Dependent); | |||
1601 | LookupPtr.setPointer(M); | |||
1602 | return M; | |||
1603 | } | |||
1604 | ||||
1605 | void ASTContext::ReleaseDeclContextMaps() { | |||
1606 | // It's okay to delete DependentStoredDeclsMaps via a StoredDeclsMap | |||
1607 | // pointer because the subclass doesn't add anything that needs to | |||
1608 | // be deleted. | |||
1609 | StoredDeclsMap::DestroyAll(LastSDM.getPointer(), LastSDM.getInt()); | |||
1610 | } | |||
1611 | ||||
1612 | void StoredDeclsMap::DestroyAll(StoredDeclsMap *Map, bool Dependent) { | |||
1613 | while (Map) { | |||
1614 | // Advance the iteration before we invalidate memory. | |||
1615 | llvm::PointerIntPair<StoredDeclsMap*,1> Next = Map->Previous; | |||
1616 | ||||
1617 | if (Dependent) | |||
1618 | delete static_cast<DependentStoredDeclsMap*>(Map); | |||
1619 | else | |||
1620 | delete Map; | |||
1621 | ||||
1622 | Map = Next.getPointer(); | |||
1623 | Dependent = Next.getInt(); | |||
1624 | } | |||
1625 | } | |||
1626 | ||||
1627 | DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C, | |||
1628 | DeclContext *Parent, | |||
1629 | const PartialDiagnostic &PDiag) { | |||
1630 | assert(Parent->isDependentContext()((Parent->isDependentContext() && "cannot iterate dependent diagnostics of non-dependent context" ) ? static_cast<void> (0) : __assert_fail ("Parent->isDependentContext() && \"cannot iterate dependent diagnostics of non-dependent context\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1631, __PRETTY_FUNCTION__)) | |||
1631 | && "cannot iterate dependent diagnostics of non-dependent context")((Parent->isDependentContext() && "cannot iterate dependent diagnostics of non-dependent context" ) ? static_cast<void> (0) : __assert_fail ("Parent->isDependentContext() && \"cannot iterate dependent diagnostics of non-dependent context\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224369/tools/clang/lib/AST/DeclBase.cpp" , 1631, __PRETTY_FUNCTION__)); | |||
1632 | Parent = Parent->getPrimaryContext(); | |||
1633 | if (!Parent->LookupPtr.getPointer()) | |||
| ||||
1634 | Parent->CreateStoredDeclsMap(C); | |||
1635 | ||||
1636 | DependentStoredDeclsMap *Map | |||
1637 | = static_cast<DependentStoredDeclsMap*>(Parent->LookupPtr.getPointer()); | |||
| ||||
1638 | ||||
1639 | // Allocate the copy of the PartialDiagnostic via the ASTContext's | |||
1640 | // BumpPtrAllocator, rather than the ASTContext itself. | |||
1641 | PartialDiagnostic::Storage *DiagStorage = nullptr; | |||
1642 | if (PDiag.hasStorage()) | |||
1643 | DiagStorage = new (C) PartialDiagnostic::Storage; | |||
1644 | ||||
1645 | DependentDiagnostic *DD = new (C) DependentDiagnostic(PDiag, DiagStorage); | |||
1646 | ||||
1647 | // TODO: Maybe we shouldn't reverse the order during insertion. | |||
1648 | DD->NextDiagnostic = Map->FirstDiagnostic; | |||
1649 | Map->FirstDiagnostic = DD; | |||
1650 | ||||
1651 | return DD; | |||
1652 | } |