Bug Summary

File:src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/DeclBase.cpp
Warning:line 1674, column 9
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DeclBase.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include/clang/AST -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../include -I /usr/src/gnu/usr.bin/clang/libclangAST/obj -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/DeclBase.cpp
1//===- DeclBase.cpp - Declaration AST Node Implementation -----------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the Decl and DeclContext classes.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/DeclBase.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTLambda.h"
16#include "clang/AST/ASTMutationListener.h"
17#include "clang/AST/Attr.h"
18#include "clang/AST/AttrIterator.h"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclCXX.h"
21#include "clang/AST/DeclContextInternals.h"
22#include "clang/AST/DeclFriend.h"
23#include "clang/AST/DeclObjC.h"
24#include "clang/AST/DeclOpenMP.h"
25#include "clang/AST/DeclTemplate.h"
26#include "clang/AST/DependentDiagnostic.h"
27#include "clang/AST/ExternalASTSource.h"
28#include "clang/AST/Stmt.h"
29#include "clang/AST/Type.h"
30#include "clang/Basic/IdentifierTable.h"
31#include "clang/Basic/LLVM.h"
32#include "clang/Basic/LangOptions.h"
33#include "clang/Basic/ObjCRuntime.h"
34#include "clang/Basic/PartialDiagnostic.h"
35#include "clang/Basic/SourceLocation.h"
36#include "clang/Basic/TargetInfo.h"
37#include "llvm/ADT/ArrayRef.h"
38#include "llvm/ADT/PointerIntPair.h"
39#include "llvm/ADT/SmallVector.h"
40#include "llvm/ADT/StringRef.h"
41#include "llvm/Support/Casting.h"
42#include "llvm/Support/ErrorHandling.h"
43#include "llvm/Support/MathExtras.h"
44#include "llvm/Support/VersionTuple.h"
45#include "llvm/Support/raw_ostream.h"
46#include <algorithm>
47#include <cassert>
48#include <cstddef>
49#include <string>
50#include <tuple>
51#include <utility>
52
53using namespace clang;
54
55//===----------------------------------------------------------------------===//
56// Statistics
57//===----------------------------------------------------------------------===//
58
59#define DECL(DERIVED, BASE) static int n##DERIVED##s = 0;
60#define ABSTRACT_DECL(DECL)
61#include "clang/AST/DeclNodes.inc"
62
63void Decl::updateOutOfDate(IdentifierInfo &II) const {
64 getASTContext().getExternalSource()->updateOutOfDateIdentifier(II);
65}
66
67#define DECL(DERIVED, BASE) \
68 static_assert(alignof(Decl) >= alignof(DERIVED##Decl), \
69 "Alignment sufficient after objects prepended to " #DERIVED);
70#define ABSTRACT_DECL(DECL)
71#include "clang/AST/DeclNodes.inc"
72
73void *Decl::operator new(std::size_t Size, const ASTContext &Context,
74 unsigned ID, std::size_t Extra) {
75 // Allocate an extra 8 bytes worth of storage, which ensures that the
76 // resulting pointer will still be 8-byte aligned.
77 static_assert(sizeof(unsigned) * 2 >= alignof(Decl),
78 "Decl won't be misaligned");
79 void *Start = Context.Allocate(Size + Extra + 8);
80 void *Result = (char*)Start + 8;
81
82 unsigned *PrefixPtr = (unsigned *)Result - 2;
83
84 // Zero out the first 4 bytes; this is used to store the owning module ID.
85 PrefixPtr[0] = 0;
86
87 // Store the global declaration ID in the second 4 bytes.
88 PrefixPtr[1] = ID;
89
90 return Result;
91}
92
93void *Decl::operator new(std::size_t Size, const ASTContext &Ctx,
94 DeclContext *Parent, std::size_t Extra) {
95 assert(!Parent || &Parent->getParentASTContext() == &Ctx)((void)0);
96 // With local visibility enabled, we track the owning module even for local
97 // declarations. We create the TU decl early and may not yet know what the
98 // LangOpts are, so conservatively allocate the storage.
99 if (Ctx.getLangOpts().trackLocalOwningModule() || !Parent) {
100 // Ensure required alignment of the resulting object by adding extra
101 // padding at the start if required.
102 size_t ExtraAlign =
103 llvm::offsetToAlignment(sizeof(Module *), llvm::Align(alignof(Decl)));
104 auto *Buffer = reinterpret_cast<char *>(
105 ::operator new(ExtraAlign + sizeof(Module *) + Size + Extra, Ctx));
106 Buffer += ExtraAlign;
107 auto *ParentModule =
108 Parent ? cast<Decl>(Parent)->getOwningModule() : nullptr;
109 return new (Buffer) Module*(ParentModule) + 1;
110 }
111 return ::operator new(Size + Extra, Ctx);
112}
113
114Module *Decl::getOwningModuleSlow() const {
115 assert(isFromASTFile() && "Not from AST file?")((void)0);
116 return getASTContext().getExternalSource()->getModule(getOwningModuleID());
117}
118
119bool Decl::hasLocalOwningModuleStorage() const {
120 return getASTContext().getLangOpts().trackLocalOwningModule();
121}
122
123const char *Decl::getDeclKindName() const {
124 switch (DeclKind) {
125 default: llvm_unreachable("Declaration not in DeclNodes.inc!")__builtin_unreachable();
126#define DECL(DERIVED, BASE) case DERIVED: return #DERIVED;
127#define ABSTRACT_DECL(DECL)
128#include "clang/AST/DeclNodes.inc"
129 }
130}
131
132void Decl::setInvalidDecl(bool Invalid) {
133 InvalidDecl = Invalid;
134 assert(!isa<TagDecl>(this) || !cast<TagDecl>(this)->isCompleteDefinition())((void)0);
135 if (!Invalid) {
136 return;
137 }
138
139 if (!isa<ParmVarDecl>(this)) {
140 // Defensive maneuver for ill-formed code: we're likely not to make it to
141 // a point where we set the access specifier, so default it to "public"
142 // to avoid triggering asserts elsewhere in the front end.
143 setAccess(AS_public);
144 }
145
146 // Marking a DecompositionDecl as invalid implies all the child BindingDecl's
147 // are invalid too.
148 if (auto *DD = dyn_cast<DecompositionDecl>(this)) {
149 for (auto *Binding : DD->bindings()) {
150 Binding->setInvalidDecl();
151 }
152 }
153}
154
155const char *DeclContext::getDeclKindName() const {
156 switch (getDeclKind()) {
157#define DECL(DERIVED, BASE) case Decl::DERIVED: return #DERIVED;
158#define ABSTRACT_DECL(DECL)
159#include "clang/AST/DeclNodes.inc"
160 }
161 llvm_unreachable("Declaration context not in DeclNodes.inc!")__builtin_unreachable();
162}
163
164bool Decl::StatisticsEnabled = false;
165void Decl::EnableStatistics() {
166 StatisticsEnabled = true;
167}
168
169void Decl::PrintStats() {
170 llvm::errs() << "\n*** Decl Stats:\n";
171
172 int totalDecls = 0;
173#define DECL(DERIVED, BASE) totalDecls += n##DERIVED##s;
174#define ABSTRACT_DECL(DECL)
175#include "clang/AST/DeclNodes.inc"
176 llvm::errs() << " " << totalDecls << " decls total.\n";
177
178 int totalBytes = 0;
179#define DECL(DERIVED, BASE) \
180 if (n##DERIVED##s > 0) { \
181 totalBytes += (int)(n##DERIVED##s * sizeof(DERIVED##Decl)); \
182 llvm::errs() << " " << n##DERIVED##s << " " #DERIVED " decls, " \
183 << sizeof(DERIVED##Decl) << " each (" \
184 << n##DERIVED##s * sizeof(DERIVED##Decl) \
185 << " bytes)\n"; \
186 }
187#define ABSTRACT_DECL(DECL)
188#include "clang/AST/DeclNodes.inc"
189
190 llvm::errs() << "Total bytes = " << totalBytes << "\n";
191}
192
193void Decl::add(Kind k) {
194 switch (k) {
195#define DECL(DERIVED, BASE) case DERIVED: ++n##DERIVED##s; break;
196#define ABSTRACT_DECL(DECL)
197#include "clang/AST/DeclNodes.inc"
198 }
199}
200
201bool Decl::isTemplateParameterPack() const {
202 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(this))
203 return TTP->isParameterPack();
204 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(this))
205 return NTTP->isParameterPack();
206 if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(this))
207 return TTP->isParameterPack();
208 return false;
209}
210
211bool Decl::isParameterPack() const {
212 if (const auto *Var = dyn_cast<VarDecl>(this))
213 return Var->isParameterPack();
214
215 return isTemplateParameterPack();
216}
217
218FunctionDecl *Decl::getAsFunction() {
219 if (auto *FD = dyn_cast<FunctionDecl>(this))
220 return FD;
221 if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(this))
222 return FTD->getTemplatedDecl();
223 return nullptr;
224}
225
226bool Decl::isTemplateDecl() const {
227 return isa<TemplateDecl>(this);
228}
229
230TemplateDecl *Decl::getDescribedTemplate() const {
231 if (auto *FD = dyn_cast<FunctionDecl>(this))
232 return FD->getDescribedFunctionTemplate();
233 if (auto *RD = dyn_cast<CXXRecordDecl>(this))
234 return RD->getDescribedClassTemplate();
235 if (auto *VD = dyn_cast<VarDecl>(this))
236 return VD->getDescribedVarTemplate();
237 if (auto *AD = dyn_cast<TypeAliasDecl>(this))
238 return AD->getDescribedAliasTemplate();
239
240 return nullptr;
241}
242
243const TemplateParameterList *Decl::getDescribedTemplateParams() const {
244 if (auto *TD = getDescribedTemplate())
245 return TD->getTemplateParameters();
246 if (auto *CTPSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(this))
247 return CTPSD->getTemplateParameters();
248 if (auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl>(this))
249 return VTPSD->getTemplateParameters();
250 return nullptr;
251}
252
253bool Decl::isTemplated() const {
254 // A declaration is templated if it is a template or a template pattern, or
255 // is within (lexcially for a friend, semantically otherwise) a dependent
256 // context.
257 // FIXME: Should local extern declarations be treated like friends?
258 if (auto *AsDC = dyn_cast<DeclContext>(this))
259 return AsDC->isDependentContext();
260 auto *DC = getFriendObjectKind() ? getLexicalDeclContext() : getDeclContext();
261 return DC->isDependentContext() || isTemplateDecl() ||
262 getDescribedTemplateParams();
263}
264
265unsigned Decl::getTemplateDepth() const {
266 if (auto *DC = dyn_cast<DeclContext>(this))
267 if (DC->isFileContext())
268 return 0;
269
270 if (auto *TPL = getDescribedTemplateParams())
271 return TPL->getDepth() + 1;
272
273 // If this is a dependent lambda, there might be an enclosing variable
274 // template. In this case, the next step is not the parent DeclContext (or
275 // even a DeclContext at all).
276 auto *RD = dyn_cast<CXXRecordDecl>(this);
277 if (RD && RD->isDependentLambda())
278 if (Decl *Context = RD->getLambdaContextDecl())
279 return Context->getTemplateDepth();
280
281 const DeclContext *DC =
282 getFriendObjectKind() ? getLexicalDeclContext() : getDeclContext();
283 return cast<Decl>(DC)->getTemplateDepth();
284}
285
286const DeclContext *Decl::getParentFunctionOrMethod() const {
287 for (const DeclContext *DC = getDeclContext();
288 DC && !DC->isTranslationUnit() && !DC->isNamespace();
289 DC = DC->getParent())
290 if (DC->isFunctionOrMethod())
291 return DC;
292
293 return nullptr;
294}
295
296//===----------------------------------------------------------------------===//
297// PrettyStackTraceDecl Implementation
298//===----------------------------------------------------------------------===//
299
300void PrettyStackTraceDecl::print(raw_ostream &OS) const {
301 SourceLocation TheLoc = Loc;
302 if (TheLoc.isInvalid() && TheDecl)
303 TheLoc = TheDecl->getLocation();
304
305 if (TheLoc.isValid()) {
306 TheLoc.print(OS, SM);
307 OS << ": ";
308 }
309
310 OS << Message;
311
312 if (const auto *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) {
313 OS << " '";
314 DN->printQualifiedName(OS);
315 OS << '\'';
316 }
317 OS << '\n';
318}
319
320//===----------------------------------------------------------------------===//
321// Decl Implementation
322//===----------------------------------------------------------------------===//
323
324// Out-of-line virtual method providing a home for Decl.
325Decl::~Decl() = default;
326
327void Decl::setDeclContext(DeclContext *DC) {
328 DeclCtx = DC;
329}
330
331void Decl::setLexicalDeclContext(DeclContext *DC) {
332 if (DC == getLexicalDeclContext())
333 return;
334
335 if (isInSemaDC()) {
336 setDeclContextsImpl(getDeclContext(), DC, getASTContext());
337 } else {
338 getMultipleDC()->LexicalDC = DC;
339 }
340
341 // FIXME: We shouldn't be changing the lexical context of declarations
342 // imported from AST files.
343 if (!isFromASTFile()) {
344 setModuleOwnershipKind(getModuleOwnershipKindForChildOf(DC));
345 if (hasOwningModule())
346 setLocalOwningModule(cast<Decl>(DC)->getOwningModule());
347 }
348
349 assert(((void)0)
350 (getModuleOwnershipKind() != ModuleOwnershipKind::VisibleWhenImported ||((void)0)
351 getOwningModule()) &&((void)0)
352 "hidden declaration has no owning module")((void)0);
353}
354
355void Decl::setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC,
356 ASTContext &Ctx) {
357 if (SemaDC == LexicalDC) {
358 DeclCtx = SemaDC;
359 } else {
360 auto *MDC = new (Ctx) Decl::MultipleDC();
361 MDC->SemanticDC = SemaDC;
362 MDC->LexicalDC = LexicalDC;
363 DeclCtx = MDC;
364 }
365}
366
367bool Decl::isInLocalScopeForInstantiation() const {
368 const DeclContext *LDC = getLexicalDeclContext();
369 if (!LDC->isDependentContext())
370 return false;
371 while (true) {
372 if (LDC->isFunctionOrMethod())
373 return true;
374 if (!isa<TagDecl>(LDC))
375 return false;
376 if (const auto *CRD = dyn_cast<CXXRecordDecl>(LDC))
377 if (CRD->isLambda())
378 return true;
379 LDC = LDC->getLexicalParent();
380 }
381 return false;
382}
383
384bool Decl::isInAnonymousNamespace() const {
385 for (const DeclContext *DC = getDeclContext(); DC; DC = DC->getParent()) {
386 if (const auto *ND = dyn_cast<NamespaceDecl>(DC))
387 if (ND->isAnonymousNamespace())
388 return true;
389 }
390
391 return false;
392}
393
394bool Decl::isInStdNamespace() const {
395 const DeclContext *DC = getDeclContext();
396 return DC && DC->isStdNamespace();
397}
398
399TranslationUnitDecl *Decl::getTranslationUnitDecl() {
400 if (auto *TUD = dyn_cast<TranslationUnitDecl>(this))
401 return TUD;
402
403 DeclContext *DC = getDeclContext();
404 assert(DC && "This decl is not contained in a translation unit!")((void)0);
405
406 while (!DC->isTranslationUnit()) {
407 DC = DC->getParent();
408 assert(DC && "This decl is not contained in a translation unit!")((void)0);
409 }
410
411 return cast<TranslationUnitDecl>(DC);
412}
413
414ASTContext &Decl::getASTContext() const {
415 return getTranslationUnitDecl()->getASTContext();
416}
417
418/// Helper to get the language options from the ASTContext.
419/// Defined out of line to avoid depending on ASTContext.h.
420const LangOptions &Decl::getLangOpts() const {
421 return getASTContext().getLangOpts();
422}
423
424ASTMutationListener *Decl::getASTMutationListener() const {
425 return getASTContext().getASTMutationListener();
426}
427
428unsigned Decl::getMaxAlignment() const {
429 if (!hasAttrs())
430 return 0;
431
432 unsigned Align = 0;
433 const AttrVec &V = getAttrs();
434 ASTContext &Ctx = getASTContext();
435 specific_attr_iterator<AlignedAttr> I(V.begin()), E(V.end());
436 for (; I != E; ++I) {
437 if (!I->isAlignmentErrorDependent())
438 Align = std::max(Align, I->getAlignment(Ctx));
439 }
440 return Align;
441}
442
443bool Decl::isUsed(bool CheckUsedAttr) const {
444 const Decl *CanonD = getCanonicalDecl();
445 if (CanonD->Used)
446 return true;
447
448 // Check for used attribute.
449 // Ask the most recent decl, since attributes accumulate in the redecl chain.
450 if (CheckUsedAttr && getMostRecentDecl()->hasAttr<UsedAttr>())
451 return true;
452
453 // The information may have not been deserialized yet. Force deserialization
454 // to complete the needed information.
455 return getMostRecentDecl()->getCanonicalDecl()->Used;
456}
457
458void Decl::markUsed(ASTContext &C) {
459 if (isUsed(false))
460 return;
461
462 if (C.getASTMutationListener())
463 C.getASTMutationListener()->DeclarationMarkedUsed(this);
464
465 setIsUsed();
466}
467
468bool Decl::isReferenced() const {
469 if (Referenced)
470 return true;
471
472 // Check redeclarations.
473 for (const auto *I : redecls())
474 if (I->Referenced)
475 return true;
476
477 return false;
478}
479
480ExternalSourceSymbolAttr *Decl::getExternalSourceSymbolAttr() const {
481 const Decl *Definition = nullptr;
482 if (auto *ID = dyn_cast<ObjCInterfaceDecl>(this)) {
483 Definition = ID->getDefinition();
484 } else if (auto *PD = dyn_cast<ObjCProtocolDecl>(this)) {
485 Definition = PD->getDefinition();
486 } else if (auto *TD = dyn_cast<TagDecl>(this)) {
487 Definition = TD->getDefinition();
488 }
489 if (!Definition)
490 Definition = this;
491
492 if (auto *attr = Definition->getAttr<ExternalSourceSymbolAttr>())
493 return attr;
494 if (auto *dcd = dyn_cast<Decl>(getDeclContext())) {
495 return dcd->getAttr<ExternalSourceSymbolAttr>();
496 }
497
498 return nullptr;
499}
500
501bool Decl::hasDefiningAttr() const {
502 return hasAttr<AliasAttr>() || hasAttr<IFuncAttr>() ||
503 hasAttr<LoaderUninitializedAttr>();
504}
505
506const Attr *Decl::getDefiningAttr() const {
507 if (auto *AA = getAttr<AliasAttr>())
508 return AA;
509 if (auto *IFA = getAttr<IFuncAttr>())
510 return IFA;
511 if (auto *NZA = getAttr<LoaderUninitializedAttr>())
512 return NZA;
513 return nullptr;
514}
515
516static StringRef getRealizedPlatform(const AvailabilityAttr *A,
517 const ASTContext &Context) {
518 // Check if this is an App Extension "platform", and if so chop off
519 // the suffix for matching with the actual platform.
520 StringRef RealizedPlatform = A->getPlatform()->getName();
521 if (!Context.getLangOpts().AppExt)
522 return RealizedPlatform;
523 size_t suffix = RealizedPlatform.rfind("_app_extension");
524 if (suffix != StringRef::npos)
525 return RealizedPlatform.slice(0, suffix);
526 return RealizedPlatform;
527}
528
529/// Determine the availability of the given declaration based on
530/// the target platform.
531///
532/// When it returns an availability result other than \c AR_Available,
533/// if the \p Message parameter is non-NULL, it will be set to a
534/// string describing why the entity is unavailable.
535///
536/// FIXME: Make these strings localizable, since they end up in
537/// diagnostics.
538static AvailabilityResult CheckAvailability(ASTContext &Context,
539 const AvailabilityAttr *A,
540 std::string *Message,
541 VersionTuple EnclosingVersion) {
542 if (EnclosingVersion.empty())
543 EnclosingVersion = Context.getTargetInfo().getPlatformMinVersion();
544
545 if (EnclosingVersion.empty())
546 return AR_Available;
547
548 StringRef ActualPlatform = A->getPlatform()->getName();
549 StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
550
551 // Match the platform name.
552 if (getRealizedPlatform(A, Context) != TargetPlatform)
553 return AR_Available;
554
555 StringRef PrettyPlatformName
556 = AvailabilityAttr::getPrettyPlatformName(ActualPlatform);
557
558 if (PrettyPlatformName.empty())
559 PrettyPlatformName = ActualPlatform;
560
561 std::string HintMessage;
562 if (!A->getMessage().empty()) {
563 HintMessage = " - ";
564 HintMessage += A->getMessage();
565 }
566
567 // Make sure that this declaration has not been marked 'unavailable'.
568 if (A->getUnavailable()) {
569 if (Message) {
570 Message->clear();
571 llvm::raw_string_ostream Out(*Message);
572 Out << "not available on " << PrettyPlatformName
573 << HintMessage;
574 }
575
576 return AR_Unavailable;
577 }
578
579 // Make sure that this declaration has already been introduced.
580 if (!A->getIntroduced().empty() &&
581 EnclosingVersion < A->getIntroduced()) {
582 if (Message) {
583 Message->clear();
584 llvm::raw_string_ostream Out(*Message);
585 VersionTuple VTI(A->getIntroduced());
586 Out << "introduced in " << PrettyPlatformName << ' '
587 << VTI << HintMessage;
588 }
589
590 return A->getStrict() ? AR_Unavailable : AR_NotYetIntroduced;
591 }
592
593 // Make sure that this declaration hasn't been obsoleted.
594 if (!A->getObsoleted().empty() && EnclosingVersion >= A->getObsoleted()) {
595 if (Message) {
596 Message->clear();
597 llvm::raw_string_ostream Out(*Message);
598 VersionTuple VTO(A->getObsoleted());
599 Out << "obsoleted in " << PrettyPlatformName << ' '
600 << VTO << HintMessage;
601 }
602
603 return AR_Unavailable;
604 }
605
606 // Make sure that this declaration hasn't been deprecated.
607 if (!A->getDeprecated().empty() && EnclosingVersion >= A->getDeprecated()) {
608 if (Message) {
609 Message->clear();
610 llvm::raw_string_ostream Out(*Message);
611 VersionTuple VTD(A->getDeprecated());
612 Out << "first deprecated in " << PrettyPlatformName << ' '
613 << VTD << HintMessage;
614 }
615
616 return AR_Deprecated;
617 }
618
619 return AR_Available;
620}
621
622AvailabilityResult Decl::getAvailability(std::string *Message,
623 VersionTuple EnclosingVersion,
624 StringRef *RealizedPlatform) const {
625 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(this))
626 return FTD->getTemplatedDecl()->getAvailability(Message, EnclosingVersion,
627 RealizedPlatform);
628
629 AvailabilityResult Result = AR_Available;
630 std::string ResultMessage;
631
632 for (const auto *A : attrs()) {
633 if (const auto *Deprecated = dyn_cast<DeprecatedAttr>(A)) {
634 if (Result >= AR_Deprecated)
635 continue;
636
637 if (Message)
638 ResultMessage = std::string(Deprecated->getMessage());
639
640 Result = AR_Deprecated;
641 continue;
642 }
643
644 if (const auto *Unavailable = dyn_cast<UnavailableAttr>(A)) {
645 if (Message)
646 *Message = std::string(Unavailable->getMessage());
647 return AR_Unavailable;
648 }
649
650 if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
651 AvailabilityResult AR = CheckAvailability(getASTContext(), Availability,
652 Message, EnclosingVersion);
653
654 if (AR == AR_Unavailable) {
655 if (RealizedPlatform)
656 *RealizedPlatform = Availability->getPlatform()->getName();
657 return AR_Unavailable;
658 }
659
660 if (AR > Result) {
661 Result = AR;
662 if (Message)
663 ResultMessage.swap(*Message);
664 }
665 continue;
666 }
667 }
668
669 if (Message)
670 Message->swap(ResultMessage);
671 return Result;
672}
673
674VersionTuple Decl::getVersionIntroduced() const {
675 const ASTContext &Context = getASTContext();
676 StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
677 for (const auto *A : attrs()) {
678 if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
679 if (getRealizedPlatform(Availability, Context) != TargetPlatform)
680 continue;
681 if (!Availability->getIntroduced().empty())
682 return Availability->getIntroduced();
683 }
684 }
685 return {};
686}
687
688bool Decl::canBeWeakImported(bool &IsDefinition) const {
689 IsDefinition = false;
690
691 // Variables, if they aren't definitions.
692 if (const auto *Var = dyn_cast<VarDecl>(this)) {
693 if (Var->isThisDeclarationADefinition()) {
694 IsDefinition = true;
695 return false;
696 }
697 return true;
698 }
699 // Functions, if they aren't definitions.
700 if (const auto *FD = dyn_cast<FunctionDecl>(this)) {
701 if (FD->hasBody()) {
702 IsDefinition = true;
703 return false;
704 }
705 return true;
706
707 }
708 // Objective-C classes, if this is the non-fragile runtime.
709 if (isa<ObjCInterfaceDecl>(this) &&
710 getASTContext().getLangOpts().ObjCRuntime.hasWeakClassImport()) {
711 return true;
712 }
713 // Nothing else.
714 return false;
715}
716
717bool Decl::isWeakImported() const {
718 bool IsDefinition;
719 if (!canBeWeakImported(IsDefinition))
720 return false;
721
722 for (const auto *A : getMostRecentDecl()->attrs()) {
723 if (isa<WeakImportAttr>(A))
724 return true;
725
726 if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
727 if (CheckAvailability(getASTContext(), Availability, nullptr,
728 VersionTuple()) == AR_NotYetIntroduced)
729 return true;
730 }
731 }
732
733 return false;
734}
735
736unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) {
737 switch (DeclKind) {
738 case Function:
739 case CXXDeductionGuide:
740 case CXXMethod:
741 case CXXConstructor:
742 case ConstructorUsingShadow:
743 case CXXDestructor:
744 case CXXConversion:
745 case EnumConstant:
746 case Var:
747 case ImplicitParam:
748 case ParmVar:
749 case ObjCMethod:
750 case ObjCProperty:
751 case MSProperty:
752 return IDNS_Ordinary;
753 case Label:
754 return IDNS_Label;
755 case IndirectField:
756 return IDNS_Ordinary | IDNS_Member;
757
758 case Binding:
759 case NonTypeTemplateParm:
760 case VarTemplate:
761 case Concept:
762 // These (C++-only) declarations are found by redeclaration lookup for
763 // tag types, so we include them in the tag namespace.
764 return IDNS_Ordinary | IDNS_Tag;
765
766 case ObjCCompatibleAlias:
767 case ObjCInterface:
768 return IDNS_Ordinary | IDNS_Type;
769
770 case Typedef:
771 case TypeAlias:
772 case TemplateTypeParm:
773 case ObjCTypeParam:
774 return IDNS_Ordinary | IDNS_Type;
775
776 case UnresolvedUsingTypename:
777 return IDNS_Ordinary | IDNS_Type | IDNS_Using;
778
779 case UsingShadow:
780 return 0; // we'll actually overwrite this later
781
782 case UnresolvedUsingValue:
783 return IDNS_Ordinary | IDNS_Using;
784
785 case Using:
786 case UsingPack:
787 case UsingEnum:
788 return IDNS_Using;
789
790 case ObjCProtocol:
791 return IDNS_ObjCProtocol;
792
793 case Field:
794 case ObjCAtDefsField:
795 case ObjCIvar:
796 return IDNS_Member;
797
798 case Record:
799 case CXXRecord:
800 case Enum:
801 return IDNS_Tag | IDNS_Type;
802
803 case Namespace:
804 case NamespaceAlias:
805 return IDNS_Namespace;
806
807 case FunctionTemplate:
808 return IDNS_Ordinary;
809
810 case ClassTemplate:
811 case TemplateTemplateParm:
812 case TypeAliasTemplate:
813 return IDNS_Ordinary | IDNS_Tag | IDNS_Type;
814
815 case UnresolvedUsingIfExists:
816 return IDNS_Type | IDNS_Ordinary;
817
818 case OMPDeclareReduction:
819 return IDNS_OMPReduction;
820
821 case OMPDeclareMapper:
822 return IDNS_OMPMapper;
823
824 // Never have names.
825 case Friend:
826 case FriendTemplate:
827 case AccessSpec:
828 case LinkageSpec:
829 case Export:
830 case FileScopeAsm:
831 case StaticAssert:
832 case ObjCPropertyImpl:
833 case PragmaComment:
834 case PragmaDetectMismatch:
835 case Block:
836 case Captured:
837 case TranslationUnit:
838 case ExternCContext:
839 case Decomposition:
840 case MSGuid:
841 case TemplateParamObject:
842
843 case UsingDirective:
844 case BuiltinTemplate:
845 case ClassTemplateSpecialization:
846 case ClassTemplatePartialSpecialization:
847 case ClassScopeFunctionSpecialization:
848 case VarTemplateSpecialization:
849 case VarTemplatePartialSpecialization:
850 case ObjCImplementation:
851 case ObjCCategory:
852 case ObjCCategoryImpl:
853 case Import:
854 case OMPThreadPrivate:
855 case OMPAllocate:
856 case OMPRequires:
857 case OMPCapturedExpr:
858 case Empty:
859 case LifetimeExtendedTemporary:
860 case RequiresExprBody:
861 // Never looked up by name.
862 return 0;
863 }
864
865 llvm_unreachable("Invalid DeclKind!")__builtin_unreachable();
866}
867
868void Decl::setAttrsImpl(const AttrVec &attrs, ASTContext &Ctx) {
869 assert(!HasAttrs && "Decl already contains attrs.")((void)0);
870
871 AttrVec &AttrBlank = Ctx.getDeclAttrs(this);
872 assert(AttrBlank.empty() && "HasAttrs was wrong?")((void)0);
873
874 AttrBlank = attrs;
875 HasAttrs = true;
876}
877
878void Decl::dropAttrs() {
879 if (!HasAttrs) return;
880
881 HasAttrs = false;
882 getASTContext().eraseDeclAttrs(this);
883}
884
885void Decl::addAttr(Attr *A) {
886 if (!hasAttrs()) {
887 setAttrs(AttrVec(1, A));
888 return;
889 }
890
891 AttrVec &Attrs = getAttrs();
892 if (!A->isInherited()) {
893 Attrs.push_back(A);
894 return;
895 }
896
897 // Attribute inheritance is processed after attribute parsing. To keep the
898 // order as in the source code, add inherited attributes before non-inherited
899 // ones.
900 auto I = Attrs.begin(), E = Attrs.end();
901 for (; I != E; ++I) {
902 if (!(*I)->isInherited())
903 break;
904 }
905 Attrs.insert(I, A);
906}
907
908const AttrVec &Decl::getAttrs() const {
909 assert(HasAttrs && "No attrs to get!")((void)0);
910 return getASTContext().getDeclAttrs(this);
911}
912
913Decl *Decl::castFromDeclContext (const DeclContext *D) {
914 Decl::Kind DK = D->getDeclKind();
915 switch(DK) {
916#define DECL(NAME, BASE)
917#define DECL_CONTEXT(NAME) \
918 case Decl::NAME: \
919 return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D));
920#define DECL_CONTEXT_BASE(NAME)
921#include "clang/AST/DeclNodes.inc"
922 default:
923#define DECL(NAME, BASE)
924#define DECL_CONTEXT_BASE(NAME) \
925 if (DK >= first##NAME && DK <= last##NAME) \
926 return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D));
927#include "clang/AST/DeclNodes.inc"
928 llvm_unreachable("a decl that inherits DeclContext isn't handled")__builtin_unreachable();
929 }
930}
931
932DeclContext *Decl::castToDeclContext(const Decl *D) {
933 Decl::Kind DK = D->getKind();
934 switch(DK) {
935#define DECL(NAME, BASE)
936#define DECL_CONTEXT(NAME) \
937 case Decl::NAME: \
938 return static_cast<NAME##Decl *>(const_cast<Decl *>(D));
939#define DECL_CONTEXT_BASE(NAME)
940#include "clang/AST/DeclNodes.inc"
941 default:
942#define DECL(NAME, BASE)
943#define DECL_CONTEXT_BASE(NAME) \
944 if (DK >= first##NAME && DK <= last##NAME) \
945 return static_cast<NAME##Decl *>(const_cast<Decl *>(D));
946#include "clang/AST/DeclNodes.inc"
947 llvm_unreachable("a decl that inherits DeclContext isn't handled")__builtin_unreachable();
948 }
949}
950
951SourceLocation Decl::getBodyRBrace() const {
952 // Special handling of FunctionDecl to avoid de-serializing the body from PCH.
953 // FunctionDecl stores EndRangeLoc for this purpose.
954 if (const auto *FD = dyn_cast<FunctionDecl>(this)) {
955 const FunctionDecl *Definition;
956 if (FD->hasBody(Definition))
957 return Definition->getSourceRange().getEnd();
958 return {};
959 }
960
961 if (Stmt *Body = getBody())
962 return Body->getSourceRange().getEnd();
963
964 return {};
965}
966
967bool Decl::AccessDeclContextSanity() const {
968#ifndef NDEBUG1
969 // Suppress this check if any of the following hold:
970 // 1. this is the translation unit (and thus has no parent)
971 // 2. this is a template parameter (and thus doesn't belong to its context)
972 // 3. this is a non-type template parameter
973 // 4. the context is not a record
974 // 5. it's invalid
975 // 6. it's a C++0x static_assert.
976 // 7. it's a block literal declaration
977 // 8. it's a temporary with lifetime extended due to being default value.
978 if (isa<TranslationUnitDecl>(this) || isa<TemplateTypeParmDecl>(this) ||
979 isa<NonTypeTemplateParmDecl>(this) || !getDeclContext() ||
980 !isa<CXXRecordDecl>(getDeclContext()) || isInvalidDecl() ||
981 isa<StaticAssertDecl>(this) || isa<BlockDecl>(this) ||
982 // FIXME: a ParmVarDecl can have ClassTemplateSpecialization
983 // as DeclContext (?).
984 isa<ParmVarDecl>(this) ||
985 // FIXME: a ClassTemplateSpecialization or CXXRecordDecl can have
986 // AS_none as access specifier.
987 isa<CXXRecordDecl>(this) ||
988 isa<ClassScopeFunctionSpecializationDecl>(this) ||
989 isa<LifetimeExtendedTemporaryDecl>(this))
990 return true;
991
992 assert(Access != AS_none &&((void)0)
993 "Access specifier is AS_none inside a record decl")((void)0);
994#endif
995 return true;
996}
997
998static Decl::Kind getKind(const Decl *D) { return D->getKind(); }
999static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); }
1000
1001int64_t Decl::getID() const {
1002 return getASTContext().getAllocator().identifyKnownAlignedObject<Decl>(this);
1003}
1004
1005const FunctionType *Decl::getFunctionType(bool BlocksToo) const {
1006 QualType Ty;
1007 if (const auto *D = dyn_cast<ValueDecl>(this))
1008 Ty = D->getType();
1009 else if (const auto *D = dyn_cast<TypedefNameDecl>(this))
1010 Ty = D->getUnderlyingType();
1011 else
1012 return nullptr;
1013
1014 if (Ty->isFunctionPointerType())
1015 Ty = Ty->castAs<PointerType>()->getPointeeType();
1016 else if (Ty->isFunctionReferenceType())
1017 Ty = Ty->castAs<ReferenceType>()->getPointeeType();
1018 else if (BlocksToo && Ty->isBlockPointerType())
1019 Ty = Ty->castAs<BlockPointerType>()->getPointeeType();
1020
1021 return Ty->getAs<FunctionType>();
1022}
1023
1024/// Starting at a given context (a Decl or DeclContext), look for a
1025/// code context that is not a closure (a lambda, block, etc.).
1026template <class T> static Decl *getNonClosureContext(T *D) {
1027 if (getKind(D) == Decl::CXXMethod) {
1028 auto *MD = cast<CXXMethodDecl>(D);
1029 if (MD->getOverloadedOperator() == OO_Call &&
1030 MD->getParent()->isLambda())
1031 return getNonClosureContext(MD->getParent()->getParent());
1032 return MD;
1033 }
1034 if (auto *FD = dyn_cast<FunctionDecl>(D))
1035 return FD;
1036 if (auto *MD = dyn_cast<ObjCMethodDecl>(D))
1037 return MD;
1038 if (auto *BD = dyn_cast<BlockDecl>(D))
1039 return getNonClosureContext(BD->getParent());
1040 if (auto *CD = dyn_cast<CapturedDecl>(D))
1041 return getNonClosureContext(CD->getParent());
1042 return nullptr;
1043}
1044
1045Decl *Decl::getNonClosureContext() {
1046 return ::getNonClosureContext(this);
1047}
1048
1049Decl *DeclContext::getNonClosureAncestor() {
1050 return ::getNonClosureContext(this);
1051}
1052
1053//===----------------------------------------------------------------------===//
1054// DeclContext Implementation
1055//===----------------------------------------------------------------------===//
1056
1057DeclContext::DeclContext(Decl::Kind K) {
1058 DeclContextBits.DeclKind = K;
1059 setHasExternalLexicalStorage(false);
1060 setHasExternalVisibleStorage(false);
1061 setNeedToReconcileExternalVisibleStorage(false);
1062 setHasLazyLocalLexicalLookups(false);
1063 setHasLazyExternalLexicalLookups(false);
1064 setUseQualifiedLookup(false);
1065}
1066
1067bool DeclContext::classof(const Decl *D) {
1068 switch (D->getKind()) {
1069#define DECL(NAME, BASE)
1070#define DECL_CONTEXT(NAME) case Decl::NAME:
1071#define DECL_CONTEXT_BASE(NAME)
1072#include "clang/AST/DeclNodes.inc"
1073 return true;
1074 default:
1075#define DECL(NAME, BASE)
1076#define DECL_CONTEXT_BASE(NAME) \
1077 if (D->getKind() >= Decl::first##NAME && \
1078 D->getKind() <= Decl::last##NAME) \
1079 return true;
1080#include "clang/AST/DeclNodes.inc"
1081 return false;
1082 }
1083}
1084
1085DeclContext::~DeclContext() = default;
1086
1087/// Find the parent context of this context that will be
1088/// used for unqualified name lookup.
1089///
1090/// Generally, the parent lookup context is the semantic context. However, for
1091/// a friend function the parent lookup context is the lexical context, which
1092/// is the class in which the friend is declared.
1093DeclContext *DeclContext::getLookupParent() {
1094 // FIXME: Find a better way to identify friends.
1095 if (isa<FunctionDecl>(this))
1096 if (getParent()->getRedeclContext()->isFileContext() &&
1097 getLexicalParent()->getRedeclContext()->isRecord())
1098 return getLexicalParent();
1099
1100 // A lookup within the call operator of a lambda never looks in the lambda
1101 // class; instead, skip to the context in which that closure type is
1102 // declared.
1103 if (isLambdaCallOperator(this))
1104 return getParent()->getParent();
1105
1106 return getParent();
1107}
1108
1109const BlockDecl *DeclContext::getInnermostBlockDecl() const {
1110 const DeclContext *Ctx = this;
1111
1112 do {
1113 if (Ctx->isClosure())
1114 return cast<BlockDecl>(Ctx);
1115 Ctx = Ctx->getParent();
1116 } while (Ctx);
1117
1118 return nullptr;
1119}
1120
1121bool DeclContext::isInlineNamespace() const {
1122 return isNamespace() &&
1123 cast<NamespaceDecl>(this)->isInline();
1124}
1125
1126bool DeclContext::isStdNamespace() const {
1127 if (!isNamespace())
1128 return false;
1129
1130 const auto *ND = cast<NamespaceDecl>(this);
1131 if (ND->isInline()) {
1132 return ND->getParent()->isStdNamespace();
1133 }
1134
1135 if (!getParent()->getRedeclContext()->isTranslationUnit())
1136 return false;
1137
1138 const IdentifierInfo *II = ND->getIdentifier();
1139 return II && II->isStr("std");
1140}
1141
1142bool DeclContext::isDependentContext() const {
1143 if (isFileContext())
1144 return false;
1145
1146 if (isa<ClassTemplatePartialSpecializationDecl>(this))
1147 return true;
1148
1149 if (const auto *Record = dyn_cast<CXXRecordDecl>(this)) {
1150 if (Record->getDescribedClassTemplate())
1151 return true;
1152
1153 if (Record->isDependentLambda())
1154 return true;
1155 }
1156
1157 if (const auto *Function = dyn_cast<FunctionDecl>(this)) {
1158 if (Function->getDescribedFunctionTemplate())
1159 return true;
1160
1161 // Friend function declarations are dependent if their *lexical*
1162 // context is dependent.
1163 if (cast<Decl>(this)->getFriendObjectKind())
1164 return getLexicalParent()->isDependentContext();
1165 }
1166
1167 // FIXME: A variable template is a dependent context, but is not a
1168 // DeclContext. A context within it (such as a lambda-expression)
1169 // should be considered dependent.
1170
1171 return getParent() && getParent()->isDependentContext();
1172}
1173
1174bool DeclContext::isTransparentContext() const {
1175 if (getDeclKind() == Decl::Enum)
1176 return !cast<EnumDecl>(this)->isScoped();
1177
1178 return getDeclKind() == Decl::LinkageSpec || getDeclKind() == Decl::Export;
1179}
1180
1181static bool isLinkageSpecContext(const DeclContext *DC,
1182 LinkageSpecDecl::LanguageIDs ID) {
1183 while (DC->getDeclKind() != Decl::TranslationUnit) {
1184 if (DC->getDeclKind() == Decl::LinkageSpec)
1185 return cast<LinkageSpecDecl>(DC)->getLanguage() == ID;
1186 DC = DC->getLexicalParent();
1187 }
1188 return false;
1189}
1190
1191bool DeclContext::isExternCContext() const {
1192 return isLinkageSpecContext(this, LinkageSpecDecl::lang_c);
1193}
1194
1195const LinkageSpecDecl *DeclContext::getExternCContext() const {
1196 const DeclContext *DC = this;
1197 while (DC->getDeclKind() != Decl::TranslationUnit) {
1198 if (DC->getDeclKind() == Decl::LinkageSpec &&
1199 cast<LinkageSpecDecl>(DC)->getLanguage() == LinkageSpecDecl::lang_c)
1200 return cast<LinkageSpecDecl>(DC);
1201 DC = DC->getLexicalParent();
1202 }
1203 return nullptr;
1204}
1205
1206bool DeclContext::isExternCXXContext() const {
1207 return isLinkageSpecContext(this, LinkageSpecDecl::lang_cxx);
1208}
1209
1210bool DeclContext::Encloses(const DeclContext *DC) const {
1211 if (getPrimaryContext() != this)
1212 return getPrimaryContext()->Encloses(DC);
1213
1214 for (; DC; DC = DC->getParent())
1215 if (DC->getPrimaryContext() == this)
1216 return true;
1217 return false;
1218}
1219
1220DeclContext *DeclContext::getPrimaryContext() {
1221 switch (getDeclKind()) {
1222 case Decl::ExternCContext:
1223 case Decl::LinkageSpec:
1224 case Decl::Export:
1225 case Decl::Block:
1226 case Decl::Captured:
1227 case Decl::OMPDeclareReduction:
1228 case Decl::OMPDeclareMapper:
1229 case Decl::RequiresExprBody:
1230 // There is only one DeclContext for these entities.
1231 return this;
1232
1233 case Decl::TranslationUnit:
1234 return static_cast<TranslationUnitDecl *>(this)->getFirstDecl();
1235 case Decl::Namespace:
1236 // The original namespace is our primary context.
1237 return static_cast<NamespaceDecl *>(this)->getOriginalNamespace();
1238
1239 case Decl::ObjCMethod:
1240 return this;
1241
1242 case Decl::ObjCInterface:
1243 if (auto *OID = dyn_cast<ObjCInterfaceDecl>(this))
1244 if (auto *Def = OID->getDefinition())
1245 return Def;
1246 return this;
1247
1248 case Decl::ObjCProtocol:
1249 if (auto *OPD = dyn_cast<ObjCProtocolDecl>(this))
1250 if (auto *Def = OPD->getDefinition())
1251 return Def;
1252 return this;
1253
1254 case Decl::ObjCCategory:
1255 return this;
1256
1257 case Decl::ObjCImplementation:
1258 case Decl::ObjCCategoryImpl:
1259 return this;
1260
1261 default:
1262 if (getDeclKind() >= Decl::firstTag && getDeclKind() <= Decl::lastTag) {
1263 // If this is a tag type that has a definition or is currently
1264 // being defined, that definition is our primary context.
1265 auto *Tag = cast<TagDecl>(this);
1266
1267 if (TagDecl *Def = Tag->getDefinition())
1268 return Def;
1269
1270 if (const auto *TagTy = dyn_cast<TagType>(Tag->getTypeForDecl())) {
1271 // Note, TagType::getDecl returns the (partial) definition one exists.
1272 TagDecl *PossiblePartialDef = TagTy->getDecl();
1273 if (PossiblePartialDef->isBeingDefined())
1274 return PossiblePartialDef;
1275 } else {
1276 assert(isa<InjectedClassNameType>(Tag->getTypeForDecl()))((void)0);
1277 }
1278
1279 return Tag;
1280 }
1281
1282 assert(getDeclKind() >= Decl::firstFunction &&((void)0)
1283 getDeclKind() <= Decl::lastFunction &&((void)0)
1284 "Unknown DeclContext kind")((void)0);
1285 return this;
1286 }
1287}
1288
1289template <typename T>
1290void collectAllContextsImpl(T *Self, SmallVectorImpl<DeclContext *> &Contexts) {
1291 for (T *D = Self->getMostRecentDecl(); D; D = D->getPreviousDecl())
1292 Contexts.push_back(D);
1293
1294 std::reverse(Contexts.begin(), Contexts.end());
1295}
1296
1297void DeclContext::collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts) {
1298 Contexts.clear();
1299
1300 Decl::Kind Kind = getDeclKind();
1301
1302 if (Kind == Decl::TranslationUnit)
1303 collectAllContextsImpl(static_cast<TranslationUnitDecl *>(this), Contexts);
1304 else if (Kind == Decl::Namespace)
1305 collectAllContextsImpl(static_cast<NamespaceDecl *>(this), Contexts);
1306 else
1307 Contexts.push_back(this);
1308}
1309
1310std::pair<Decl *, Decl *>
1311DeclContext::BuildDeclChain(ArrayRef<Decl *> Decls,
1312 bool FieldsAlreadyLoaded) {
1313 // Build up a chain of declarations via the Decl::NextInContextAndBits field.
1314 Decl *FirstNewDecl = nullptr;
1315 Decl *PrevDecl = nullptr;
1316 for (auto *D : Decls) {
1317 if (FieldsAlreadyLoaded && isa<FieldDecl>(D))
1318 continue;
1319
1320 if (PrevDecl)
1321 PrevDecl->NextInContextAndBits.setPointer(D);
1322 else
1323 FirstNewDecl = D;
1324
1325 PrevDecl = D;
1326 }
1327
1328 return std::make_pair(FirstNewDecl, PrevDecl);
1329}
1330
1331/// We have just acquired external visible storage, and we already have
1332/// built a lookup map. For every name in the map, pull in the new names from
1333/// the external storage.
1334void DeclContext::reconcileExternalVisibleStorage() const {
1335 assert(hasNeedToReconcileExternalVisibleStorage() && LookupPtr)((void)0);
1336 setNeedToReconcileExternalVisibleStorage(false);
1337
1338 for (auto &Lookup : *LookupPtr)
1339 Lookup.second.setHasExternalDecls();
1340}
1341
1342/// Load the declarations within this lexical storage from an
1343/// external source.
1344/// \return \c true if any declarations were added.
1345bool
1346DeclContext::LoadLexicalDeclsFromExternalStorage() const {
1347 ExternalASTSource *Source = getParentASTContext().getExternalSource();
1348 assert(hasExternalLexicalStorage() && Source && "No external storage?")((void)0);
1349
1350 // Notify that we have a DeclContext that is initializing.
1351 ExternalASTSource::Deserializing ADeclContext(Source);
1352
1353 // Load the external declarations, if any.
1354 SmallVector<Decl*, 64> Decls;
1355 setHasExternalLexicalStorage(false);
1356 Source->FindExternalLexicalDecls(this, Decls);
1357
1358 if (Decls.empty())
1359 return false;
1360
1361 // We may have already loaded just the fields of this record, in which case
1362 // we need to ignore them.
1363 bool FieldsAlreadyLoaded = false;
1364 if (const auto *RD = dyn_cast<RecordDecl>(this))
1365 FieldsAlreadyLoaded = RD->hasLoadedFieldsFromExternalStorage();
1366
1367 // Splice the newly-read declarations into the beginning of the list
1368 // of declarations.
1369 Decl *ExternalFirst, *ExternalLast;
1370 std::tie(ExternalFirst, ExternalLast) =
1371 BuildDeclChain(Decls, FieldsAlreadyLoaded);
1372 ExternalLast->NextInContextAndBits.setPointer(FirstDecl);
1373 FirstDecl = ExternalFirst;
1374 if (!LastDecl)
1375 LastDecl = ExternalLast;
1376 return true;
1377}
1378
1379DeclContext::lookup_result
1380ExternalASTSource::SetNoExternalVisibleDeclsForName(const DeclContext *DC,
1381 DeclarationName Name) {
1382 ASTContext &Context = DC->getParentASTContext();
1383 StoredDeclsMap *Map;
1384 if (!(Map = DC->LookupPtr))
1385 Map = DC->CreateStoredDeclsMap(Context);
1386 if (DC->hasNeedToReconcileExternalVisibleStorage())
1387 DC->reconcileExternalVisibleStorage();
1388
1389 (*Map)[Name].removeExternalDecls();
1390
1391 return DeclContext::lookup_result();
1392}
1393
1394DeclContext::lookup_result
1395ExternalASTSource::SetExternalVisibleDeclsForName(const DeclContext *DC,
1396 DeclarationName Name,
1397 ArrayRef<NamedDecl*> Decls) {
1398 ASTContext &Context = DC->getParentASTContext();
1399 StoredDeclsMap *Map;
1400 if (!(Map = DC->LookupPtr))
1401 Map = DC->CreateStoredDeclsMap(Context);
1402 if (DC->hasNeedToReconcileExternalVisibleStorage())
1403 DC->reconcileExternalVisibleStorage();
1404
1405 StoredDeclsList &List = (*Map)[Name];
1406 List.replaceExternalDecls(Decls);
1407 return List.getLookupResult();
1408}
1409
1410DeclContext::decl_iterator DeclContext::decls_begin() const {
1411 if (hasExternalLexicalStorage())
1412 LoadLexicalDeclsFromExternalStorage();
1413 return decl_iterator(FirstDecl);
1414}
1415
1416bool DeclContext::decls_empty() const {
1417 if (hasExternalLexicalStorage())
1418 LoadLexicalDeclsFromExternalStorage();
1419
1420 return !FirstDecl;
1421}
1422
1423bool DeclContext::containsDecl(Decl *D) const {
1424 return (D->getLexicalDeclContext() == this &&
1425 (D->NextInContextAndBits.getPointer() || D == LastDecl));
1426}
1427
1428bool DeclContext::containsDeclAndLoad(Decl *D) const {
1429 if (hasExternalLexicalStorage())
1430 LoadLexicalDeclsFromExternalStorage();
1431 return containsDecl(D);
1432}
1433
1434/// shouldBeHidden - Determine whether a declaration which was declared
1435/// within its semantic context should be invisible to qualified name lookup.
1436static bool shouldBeHidden(NamedDecl *D) {
1437 // Skip unnamed declarations.
1438 if (!D->getDeclName())
1439 return true;
1440
1441 // Skip entities that can't be found by name lookup into a particular
1442 // context.
1443 if ((D->getIdentifierNamespace() == 0 && !isa<UsingDirectiveDecl>(D)) ||
1444 D->isTemplateParameter())
1445 return true;
1446
1447 // Skip friends and local extern declarations unless they're the first
1448 // declaration of the entity.
1449 if ((D->isLocalExternDecl() || D->getFriendObjectKind()) &&
1450 D != D->getCanonicalDecl())
1451 return true;
1452
1453 // Skip template specializations.
1454 // FIXME: This feels like a hack. Should DeclarationName support
1455 // template-ids, or is there a better way to keep specializations
1456 // from being visible?
1457 if (isa<ClassTemplateSpecializationDecl>(D))
1458 return true;
1459 if (auto *FD = dyn_cast<FunctionDecl>(D))
1460 if (FD->isFunctionTemplateSpecialization())
1461 return true;
1462
1463 // Hide destructors that are invalid. There should always be one destructor,
1464 // but if it is an invalid decl, another one is created. We need to hide the
1465 // invalid one from places that expect exactly one destructor, like the
1466 // serialization code.
1467 if (isa<CXXDestructorDecl>(D) && D->isInvalidDecl())
1468 return true;
1469
1470 return false;
1471}
1472
1473void DeclContext::removeDecl(Decl *D) {
1474 assert(D->getLexicalDeclContext() == this &&((void)0)
1475 "decl being removed from non-lexical context")((void)0);
1476 assert((D->NextInContextAndBits.getPointer() || D == LastDecl) &&((void)0)
1477 "decl is not in decls list")((void)0);
1478
1479 // Remove D from the decl chain. This is O(n) but hopefully rare.
1480 if (D == FirstDecl) {
1481 if (D == LastDecl)
1482 FirstDecl = LastDecl = nullptr;
1483 else
1484 FirstDecl = D->NextInContextAndBits.getPointer();
1485 } else {
1486 for (Decl *I = FirstDecl; true; I = I->NextInContextAndBits.getPointer()) {
1487 assert(I && "decl not found in linked list")((void)0);
1488 if (I->NextInContextAndBits.getPointer() == D) {
1489 I->NextInContextAndBits.setPointer(D->NextInContextAndBits.getPointer());
1490 if (D == LastDecl) LastDecl = I;
1491 break;
1492 }
1493 }
1494 }
1495
1496 // Mark that D is no longer in the decl chain.
1497 D->NextInContextAndBits.setPointer(nullptr);
1498
1499 // Remove D from the lookup table if necessary.
1500 if (isa<NamedDecl>(D)) {
1501 auto *ND = cast<NamedDecl>(D);
1502
1503 // Do not try to remove the declaration if that is invisible to qualified
1504 // lookup. E.g. template specializations are skipped.
1505 if (shouldBeHidden(ND))
1506 return;
1507
1508 // Remove only decls that have a name
1509 if (!ND->getDeclName())
1510 return;
1511
1512 auto *DC = D->getDeclContext();
1513 do {
1514 StoredDeclsMap *Map = DC->getPrimaryContext()->LookupPtr;
1515 if (Map) {
1516 StoredDeclsMap::iterator Pos = Map->find(ND->getDeclName());
1517 assert(Pos != Map->end() && "no lookup entry for decl")((void)0);
1518 Pos->second.remove(ND);
1519 }
1520 } while (DC->isTransparentContext() && (DC = DC->getParent()));
1521 }
1522}
1523
1524void DeclContext::addHiddenDecl(Decl *D) {
1525 assert(D->getLexicalDeclContext() == this &&((void)0)
1526 "Decl inserted into wrong lexical context")((void)0);
1527 assert(!D->getNextDeclInContext() && D != LastDecl &&((void)0)
1528 "Decl already inserted into a DeclContext")((void)0);
1529
1530 if (FirstDecl) {
1531 LastDecl->NextInContextAndBits.setPointer(D);
1532 LastDecl = D;
1533 } else {
1534 FirstDecl = LastDecl = D;
1535 }
1536
1537 // Notify a C++ record declaration that we've added a member, so it can
1538 // update its class-specific state.
1539 if (auto *Record = dyn_cast<CXXRecordDecl>(this))
1540 Record->addedMember(D);
1541
1542 // If this is a newly-created (not de-serialized) import declaration, wire
1543 // it in to the list of local import declarations.
1544 if (!D->isFromASTFile()) {
1545 if (auto *Import = dyn_cast<ImportDecl>(D))
1546 D->getASTContext().addedLocalImportDecl(Import);
1547 }
1548}
1549
1550void DeclContext::addDecl(Decl *D) {
1551 addHiddenDecl(D);
1552
1553 if (auto *ND = dyn_cast<NamedDecl>(D))
1554 ND->getDeclContext()->getPrimaryContext()->
1555 makeDeclVisibleInContextWithFlags(ND, false, true);
1556}
1557
1558void DeclContext::addDeclInternal(Decl *D) {
1559 addHiddenDecl(D);
1560
1561 if (auto *ND = dyn_cast<NamedDecl>(D))
1562 ND->getDeclContext()->getPrimaryContext()->
1563 makeDeclVisibleInContextWithFlags(ND, true, true);
1564}
1565
1566/// buildLookup - Build the lookup data structure with all of the
1567/// declarations in this DeclContext (and any other contexts linked
1568/// to it or transparent contexts nested within it) and return it.
1569///
1570/// Note that the produced map may miss out declarations from an
1571/// external source. If it does, those entries will be marked with
1572/// the 'hasExternalDecls' flag.
1573StoredDeclsMap *DeclContext::buildLookup() {
1574 assert(this == getPrimaryContext() && "buildLookup called on non-primary DC")((void)0);
1575
1576 if (!hasLazyLocalLexicalLookups() &&
1577 !hasLazyExternalLexicalLookups())
1578 return LookupPtr;
1579
1580 SmallVector<DeclContext *, 2> Contexts;
1581 collectAllContexts(Contexts);
1582
1583 if (hasLazyExternalLexicalLookups()) {
1584 setHasLazyExternalLexicalLookups(false);
1585 for (auto *DC : Contexts) {
1586 if (DC->hasExternalLexicalStorage()) {
1587 bool LoadedDecls = DC->LoadLexicalDeclsFromExternalStorage();
1588 setHasLazyLocalLexicalLookups(
1589 hasLazyLocalLexicalLookups() | LoadedDecls );
1590 }
1591 }
1592
1593 if (!hasLazyLocalLexicalLookups())
1594 return LookupPtr;
1595 }
1596
1597 for (auto *DC : Contexts)
1598 buildLookupImpl(DC, hasExternalVisibleStorage());
1599
1600 // We no longer have any lazy decls.
1601 setHasLazyLocalLexicalLookups(false);
1602 return LookupPtr;
1603}
1604
1605/// buildLookupImpl - Build part of the lookup data structure for the
1606/// declarations contained within DCtx, which will either be this
1607/// DeclContext, a DeclContext linked to it, or a transparent context
1608/// nested within it.
1609void DeclContext::buildLookupImpl(DeclContext *DCtx, bool Internal) {
1610 for (auto *D : DCtx->noload_decls()) {
1611 // Insert this declaration into the lookup structure, but only if
1612 // it's semantically within its decl context. Any other decls which
1613 // should be found in this context are added eagerly.
1614 //
1615 // If it's from an AST file, don't add it now. It'll get handled by
1616 // FindExternalVisibleDeclsByName if needed. Exception: if we're not
1617 // in C++, we do not track external visible decls for the TU, so in
1618 // that case we need to collect them all here.
1619 if (auto *ND = dyn_cast<NamedDecl>(D))
1620 if (ND->getDeclContext() == DCtx && !shouldBeHidden(ND) &&
1621 (!ND->isFromASTFile() ||
1622 (isTranslationUnit() &&
1623 !getParentASTContext().getLangOpts().CPlusPlus)))
1624 makeDeclVisibleInContextImpl(ND, Internal);
1625
1626 // If this declaration is itself a transparent declaration context
1627 // or inline namespace, add the members of this declaration of that
1628 // context (recursively).
1629 if (auto *InnerCtx = dyn_cast<DeclContext>(D))
1630 if (InnerCtx->isTransparentContext() || InnerCtx->isInlineNamespace())
1631 buildLookupImpl(InnerCtx, Internal);
1632 }
1633}
1634
1635DeclContext::lookup_result
1636DeclContext::lookup(DeclarationName Name) const {
1637 assert(getDeclKind() != Decl::LinkageSpec &&((void)0)
1638 getDeclKind() != Decl::Export &&((void)0)
1639 "should not perform lookups into transparent contexts")((void)0);
1640
1641 const DeclContext *PrimaryContext = getPrimaryContext();
1642 if (PrimaryContext != this)
5
Assuming the condition is false
6
Taking false branch
1643 return PrimaryContext->lookup(Name);
1644
1645 // If we have an external source, ensure that any later redeclarations of this
1646 // context have been loaded, since they may add names to the result of this
1647 // lookup (or add external visible storage).
1648 ExternalASTSource *Source = getParentASTContext().getExternalSource();
7
'Source' initialized here
1649 if (Source)
8
Assuming 'Source' is null
9
Taking false branch
1650 (void)cast<Decl>(this)->getMostRecentDecl();
1651
1652 if (hasExternalVisibleStorage()) {
10
Assuming the condition is true
11
Taking true branch
1653 assert(Source && "external visible storage but no external source?")((void)0);
1654
1655 if (hasNeedToReconcileExternalVisibleStorage())
12
Assuming the condition is false
13
Taking false branch
1656 reconcileExternalVisibleStorage();
1657
1658 StoredDeclsMap *Map = LookupPtr;
1659
1660 if (hasLazyLocalLexicalLookups() ||
14
Assuming the condition is false
16
Taking false branch
1661 hasLazyExternalLexicalLookups())
15
Assuming the condition is false
1662 // FIXME: Make buildLookup const?
1663 Map = const_cast<DeclContext*>(this)->buildLookup();
1664
1665 if (!Map)
17
Assuming 'Map' is non-null
18
Taking false branch
1666 Map = CreateStoredDeclsMap(getParentASTContext());
1667
1668 // If we have a lookup result with no external decls, we are done.
1669 std::pair<StoredDeclsMap::iterator, bool> R =
1670 Map->insert(std::make_pair(Name, StoredDeclsList()));
1671 if (!R.second && !R.first->second.hasExternalDecls())
19
Assuming field 'second' is true
1672 return R.first->second.getLookupResult();
1673
1674 if (Source->FindExternalVisibleDeclsByName(this, Name) || !R.second) {
20
Called C++ object pointer is null
1675 if (StoredDeclsMap *Map = LookupPtr) {
1676 StoredDeclsMap::iterator I = Map->find(Name);
1677 if (I != Map->end())
1678 return I->second.getLookupResult();
1679 }
1680 }
1681
1682 return {};
1683 }
1684
1685 StoredDeclsMap *Map = LookupPtr;
1686 if (hasLazyLocalLexicalLookups() ||
1687 hasLazyExternalLexicalLookups())
1688 Map = const_cast<DeclContext*>(this)->buildLookup();
1689
1690 if (!Map)
1691 return {};
1692
1693 StoredDeclsMap::iterator I = Map->find(Name);
1694 if (I == Map->end())
1695 return {};
1696
1697 return I->second.getLookupResult();
1698}
1699
1700DeclContext::lookup_result
1701DeclContext::noload_lookup(DeclarationName Name) {
1702 assert(getDeclKind() != Decl::LinkageSpec &&((void)0)
1703 getDeclKind() != Decl::Export &&((void)0)
1704 "should not perform lookups into transparent contexts")((void)0);
1705
1706 DeclContext *PrimaryContext = getPrimaryContext();
1707 if (PrimaryContext != this)
1708 return PrimaryContext->noload_lookup(Name);
1709
1710 loadLazyLocalLexicalLookups();
1711 StoredDeclsMap *Map = LookupPtr;
1712 if (!Map)
1713 return {};
1714
1715 StoredDeclsMap::iterator I = Map->find(Name);
1716 return I != Map->end() ? I->second.getLookupResult()
1717 : lookup_result();
1718}
1719
1720// If we have any lazy lexical declarations not in our lookup map, add them
1721// now. Don't import any external declarations, not even if we know we have
1722// some missing from the external visible lookups.
1723void DeclContext::loadLazyLocalLexicalLookups() {
1724 if (hasLazyLocalLexicalLookups()) {
1725 SmallVector<DeclContext *, 2> Contexts;
1726 collectAllContexts(Contexts);
1727 for (auto *Context : Contexts)
1728 buildLookupImpl(Context, hasExternalVisibleStorage());
1729 setHasLazyLocalLexicalLookups(false);
1730 }
1731}
1732
1733void DeclContext::localUncachedLookup(DeclarationName Name,
1734 SmallVectorImpl<NamedDecl *> &Results) {
1735 Results.clear();
1736
1737 // If there's no external storage, just perform a normal lookup and copy
1738 // the results.
1739 if (!hasExternalVisibleStorage() && !hasExternalLexicalStorage() && Name) {
1
Assuming the condition is true
2
Assuming the condition is true
3
Taking true branch
1740 lookup_result LookupResults = lookup(Name);
4
Calling 'DeclContext::lookup'
1741 Results.insert(Results.end(), LookupResults.begin(), LookupResults.end());
1742 return;
1743 }
1744
1745 // If we have a lookup table, check there first. Maybe we'll get lucky.
1746 // FIXME: Should we be checking these flags on the primary context?
1747 if (Name && !hasLazyLocalLexicalLookups() &&
1748 !hasLazyExternalLexicalLookups()) {
1749 if (StoredDeclsMap *Map = LookupPtr) {
1750 StoredDeclsMap::iterator Pos = Map->find(Name);
1751 if (Pos != Map->end()) {
1752 Results.insert(Results.end(),
1753 Pos->second.getLookupResult().begin(),
1754 Pos->second.getLookupResult().end());
1755 return;
1756 }
1757 }
1758 }
1759
1760 // Slow case: grovel through the declarations in our chain looking for
1761 // matches.
1762 // FIXME: If we have lazy external declarations, this will not find them!
1763 // FIXME: Should we CollectAllContexts and walk them all here?
1764 for (Decl *D = FirstDecl; D; D = D->getNextDeclInContext()) {
1765 if (auto *ND = dyn_cast<NamedDecl>(D))
1766 if (ND->getDeclName() == Name)
1767 Results.push_back(ND);
1768 }
1769}
1770
1771DeclContext *DeclContext::getRedeclContext() {
1772 DeclContext *Ctx = this;
1773
1774 // In C, a record type is the redeclaration context for its fields only. If
1775 // we arrive at a record context after skipping anything else, we should skip
1776 // the record as well. Currently, this means skipping enumerations because
1777 // they're the only transparent context that can exist within a struct or
1778 // union.
1779 bool SkipRecords = getDeclKind() == Decl::Kind::Enum &&
1780 !getParentASTContext().getLangOpts().CPlusPlus;
1781
1782 // Skip through contexts to get to the redeclaration context. Transparent
1783 // contexts are always skipped.
1784 while ((SkipRecords && Ctx->isRecord()) || Ctx->isTransparentContext())
1785 Ctx = Ctx->getParent();
1786 return Ctx;
1787}
1788
1789DeclContext *DeclContext::getEnclosingNamespaceContext() {
1790 DeclContext *Ctx = this;
1791 // Skip through non-namespace, non-translation-unit contexts.
1792 while (!Ctx->isFileContext())
1793 Ctx = Ctx->getParent();
1794 return Ctx->getPrimaryContext();
1795}
1796
1797RecordDecl *DeclContext::getOuterLexicalRecordContext() {
1798 // Loop until we find a non-record context.
1799 RecordDecl *OutermostRD = nullptr;
1800 DeclContext *DC = this;
1801 while (DC->isRecord()) {
1802 OutermostRD = cast<RecordDecl>(DC);
1803 DC = DC->getLexicalParent();
1804 }
1805 return OutermostRD;
1806}
1807
1808bool DeclContext::InEnclosingNamespaceSetOf(const DeclContext *O) const {
1809 // For non-file contexts, this is equivalent to Equals.
1810 if (!isFileContext())
1811 return O->Equals(this);
1812
1813 do {
1814 if (O->Equals(this))
1815 return true;
1816
1817 const auto *NS = dyn_cast<NamespaceDecl>(O);
1818 if (!NS || !NS->isInline())
1819 break;
1820 O = NS->getParent();
1821 } while (O);
1822
1823 return false;
1824}
1825
1826void DeclContext::makeDeclVisibleInContext(NamedDecl *D) {
1827 DeclContext *PrimaryDC = this->getPrimaryContext();
1828 DeclContext *DeclDC = D->getDeclContext()->getPrimaryContext();
1829 // If the decl is being added outside of its semantic decl context, we
1830 // need to ensure that we eagerly build the lookup information for it.
1831 PrimaryDC->makeDeclVisibleInContextWithFlags(D, false, PrimaryDC == DeclDC);
1832}
1833
1834void DeclContext::makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,
1835 bool Recoverable) {
1836 assert(this == getPrimaryContext() && "expected a primary DC")((void)0);
1837
1838 if (!isLookupContext()) {
1839 if (isTransparentContext())
1840 getParent()->getPrimaryContext()
1841 ->makeDeclVisibleInContextWithFlags(D, Internal, Recoverable);
1842 return;
1843 }
1844
1845 // Skip declarations which should be invisible to name lookup.
1846 if (shouldBeHidden(D))
1847 return;
1848
1849 // If we already have a lookup data structure, perform the insertion into
1850 // it. If we might have externally-stored decls with this name, look them
1851 // up and perform the insertion. If this decl was declared outside its
1852 // semantic context, buildLookup won't add it, so add it now.
1853 //
1854 // FIXME: As a performance hack, don't add such decls into the translation
1855 // unit unless we're in C++, since qualified lookup into the TU is never
1856 // performed.
1857 if (LookupPtr || hasExternalVisibleStorage() ||
1858 ((!Recoverable || D->getDeclContext() != D->getLexicalDeclContext()) &&
1859 (getParentASTContext().getLangOpts().CPlusPlus ||
1860 !isTranslationUnit()))) {
1861 // If we have lazily omitted any decls, they might have the same name as
1862 // the decl which we are adding, so build a full lookup table before adding
1863 // this decl.
1864 buildLookup();
1865 makeDeclVisibleInContextImpl(D, Internal);
1866 } else {
1867 setHasLazyLocalLexicalLookups(true);
1868 }
1869
1870 // If we are a transparent context or inline namespace, insert into our
1871 // parent context, too. This operation is recursive.
1872 if (isTransparentContext() || isInlineNamespace())
1873 getParent()->getPrimaryContext()->
1874 makeDeclVisibleInContextWithFlags(D, Internal, Recoverable);
1875
1876 auto *DCAsDecl = cast<Decl>(this);
1877 // Notify that a decl was made visible unless we are a Tag being defined.
1878 if (!(isa<TagDecl>(DCAsDecl) && cast<TagDecl>(DCAsDecl)->isBeingDefined()))
1879 if (ASTMutationListener *L = DCAsDecl->getASTMutationListener())
1880 L->AddedVisibleDecl(this, D);
1881}
1882
1883void DeclContext::makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal) {
1884 // Find or create the stored declaration map.
1885 StoredDeclsMap *Map = LookupPtr;
1886 if (!Map) {
1887 ASTContext *C = &getParentASTContext();
1888 Map = CreateStoredDeclsMap(*C);
1889 }
1890
1891 // If there is an external AST source, load any declarations it knows about
1892 // with this declaration's name.
1893 // If the lookup table contains an entry about this name it means that we
1894 // have already checked the external source.
1895 if (!Internal)
1896 if (ExternalASTSource *Source = getParentASTContext().getExternalSource())
1897 if (hasExternalVisibleStorage() &&
1898 Map->find(D->getDeclName()) == Map->end())
1899 Source->FindExternalVisibleDeclsByName(this, D->getDeclName());
1900
1901 // Insert this declaration into the map.
1902 StoredDeclsList &DeclNameEntries = (*Map)[D->getDeclName()];
1903
1904 if (Internal) {
1905 // If this is being added as part of loading an external declaration,
1906 // this may not be the only external declaration with this name.
1907 // In this case, we never try to replace an existing declaration; we'll
1908 // handle that when we finalize the list of declarations for this name.
1909 DeclNameEntries.setHasExternalDecls();
1910 DeclNameEntries.prependDeclNoReplace(D);
1911 return;
1912 }
1913
1914 DeclNameEntries.addOrReplaceDecl(D);
1915}
1916
1917UsingDirectiveDecl *DeclContext::udir_iterator::operator*() const {
1918 return cast<UsingDirectiveDecl>(*I);
1919}
1920
1921/// Returns iterator range [First, Last) of UsingDirectiveDecls stored within
1922/// this context.
1923DeclContext::udir_range DeclContext::using_directives() const {
1924 // FIXME: Use something more efficient than normal lookup for using
1925 // directives. In C++, using directives are looked up more than anything else.
1926 lookup_result Result = lookup(UsingDirectiveDecl::getName());
1927 return udir_range(Result.begin(), Result.end());
1928}
1929
1930//===----------------------------------------------------------------------===//
1931// Creation and Destruction of StoredDeclsMaps. //
1932//===----------------------------------------------------------------------===//
1933
1934StoredDeclsMap *DeclContext::CreateStoredDeclsMap(ASTContext &C) const {
1935 assert(!LookupPtr && "context already has a decls map")((void)0);
1936 assert(getPrimaryContext() == this &&((void)0)
1937 "creating decls map on non-primary context")((void)0);
1938
1939 StoredDeclsMap *M;
1940 bool Dependent = isDependentContext();
1941 if (Dependent)
1942 M = new DependentStoredDeclsMap();
1943 else
1944 M = new StoredDeclsMap();
1945 M->Previous = C.LastSDM;
1946 C.LastSDM = llvm::PointerIntPair<StoredDeclsMap*,1>(M, Dependent);
1947 LookupPtr = M;
1948 return M;
1949}
1950
1951void ASTContext::ReleaseDeclContextMaps() {
1952 // It's okay to delete DependentStoredDeclsMaps via a StoredDeclsMap
1953 // pointer because the subclass doesn't add anything that needs to
1954 // be deleted.
1955 StoredDeclsMap::DestroyAll(LastSDM.getPointer(), LastSDM.getInt());
1956}
1957
1958void StoredDeclsMap::DestroyAll(StoredDeclsMap *Map, bool Dependent) {
1959 while (Map) {
1960 // Advance the iteration before we invalidate memory.
1961 llvm::PointerIntPair<StoredDeclsMap*,1> Next = Map->Previous;
1962
1963 if (Dependent)
1964 delete static_cast<DependentStoredDeclsMap*>(Map);
1965 else
1966 delete Map;
1967
1968 Map = Next.getPointer();
1969 Dependent = Next.getInt();
1970 }
1971}
1972
1973DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C,
1974 DeclContext *Parent,
1975 const PartialDiagnostic &PDiag) {
1976 assert(Parent->isDependentContext()((void)0)
1977 && "cannot iterate dependent diagnostics of non-dependent context")((void)0);
1978 Parent = Parent->getPrimaryContext();
1979 if (!Parent->LookupPtr)
1980 Parent->CreateStoredDeclsMap(C);
1981
1982 auto *Map = static_cast<DependentStoredDeclsMap *>(Parent->LookupPtr);
1983
1984 // Allocate the copy of the PartialDiagnostic via the ASTContext's
1985 // BumpPtrAllocator, rather than the ASTContext itself.
1986 DiagnosticStorage *DiagStorage = nullptr;
1987 if (PDiag.hasStorage())
1988 DiagStorage = new (C) DiagnosticStorage;
1989
1990 auto *DD = new (C) DependentDiagnostic(PDiag, DiagStorage);
1991
1992 // TODO: Maybe we shouldn't reverse the order during insertion.
1993 DD->NextDiagnostic = Map->FirstDiagnostic;
1994 Map->FirstDiagnostic = DD;
1995
1996 return DD;
1997}