clang 19.0.0git
DeclBase.cpp
Go to the documentation of this file.
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"
15#include "clang/AST/ASTLambda.h"
17#include "clang/AST/Attr.h"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclCXX.h"
23#include "clang/AST/DeclObjC.h"
28#include "clang/AST/Stmt.h"
29#include "clang/AST/Type.h"
31#include "clang/Basic/LLVM.h"
32#include "clang/Basic/Module.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
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 GlobalDeclID 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(uint64_t) >= alignof(Decl), "Decl won't be misaligned");
78 void *Start = Context.Allocate(Size + Extra + 8);
79 void *Result = (char*)Start + 8;
80
81 uint64_t *PrefixPtr = (uint64_t *)Result - 1;
82
83 *PrefixPtr = ID.getRawValue();
84
85 // We leave the upper 16 bits to store the module IDs. 48 bits should be
86 // sufficient to store a declaration ID.
87 assert(*PrefixPtr < llvm::maskTrailingOnes<uint64_t>(48));
88
89 return Result;
90}
91
92void *Decl::operator new(std::size_t Size, const ASTContext &Ctx,
93 DeclContext *Parent, std::size_t Extra) {
94 assert(!Parent || &Parent->getParentASTContext() == &Ctx);
95 // With local visibility enabled, we track the owning module even for local
96 // declarations. We create the TU decl early and may not yet know what the
97 // LangOpts are, so conservatively allocate the storage.
98 if (Ctx.getLangOpts().trackLocalOwningModule() || !Parent) {
99 // Ensure required alignment of the resulting object by adding extra
100 // padding at the start if required.
101 size_t ExtraAlign =
102 llvm::offsetToAlignment(sizeof(Module *), llvm::Align(alignof(Decl)));
103 auto *Buffer = reinterpret_cast<char *>(
104 ::operator new(ExtraAlign + sizeof(Module *) + Size + Extra, Ctx));
105 Buffer += ExtraAlign;
106 auto *ParentModule =
107 Parent ? cast<Decl>(Parent)->getOwningModule() : nullptr;
108 return new (Buffer) Module*(ParentModule) + 1;
109 }
110 return ::operator new(Size + Extra, Ctx);
111}
112
114 if (!isFromASTFile())
115 return GlobalDeclID();
116 // See the comments in `Decl::operator new` for details.
117 uint64_t ID = *((const uint64_t *)this - 1);
118 return GlobalDeclID(ID & llvm::maskTrailingOnes<uint64_t>(48));
119}
120
121unsigned Decl::getOwningModuleID() const {
122 if (!isFromASTFile())
123 return 0;
124
125 uint64_t ID = *((const uint64_t *)this - 1);
126 return ID >> 48;
127}
128
129void Decl::setOwningModuleID(unsigned ID) {
130 assert(isFromASTFile() && "Only works on a deserialized declaration");
131 uint64_t *IDAddress = (uint64_t *)this - 1;
132 *IDAddress &= llvm::maskTrailingOnes<uint64_t>(48);
133 *IDAddress |= (uint64_t)ID << 48;
134}
135
136Module *Decl::getOwningModuleSlow() const {
137 assert(isFromASTFile() && "Not from AST file?");
139}
140
143}
144
145const char *Decl::getDeclKindName() const {
146 switch (DeclKind) {
147 default: llvm_unreachable("Declaration not in DeclNodes.inc!");
148#define DECL(DERIVED, BASE) case DERIVED: return #DERIVED;
149#define ABSTRACT_DECL(DECL)
150#include "clang/AST/DeclNodes.inc"
151 }
152}
153
155 InvalidDecl = Invalid;
156 assert(!isa<TagDecl>(this) || !cast<TagDecl>(this)->isCompleteDefinition());
157 if (!Invalid) {
158 return;
159 }
160
161 if (!isa<ParmVarDecl>(this)) {
162 // Defensive maneuver for ill-formed code: we're likely not to make it to
163 // a point where we set the access specifier, so default it to "public"
164 // to avoid triggering asserts elsewhere in the front end.
166 }
167
168 // Marking a DecompositionDecl as invalid implies all the child BindingDecl's
169 // are invalid too.
170 if (auto *DD = dyn_cast<DecompositionDecl>(this)) {
171 for (auto *Binding : DD->bindings()) {
172 Binding->setInvalidDecl();
173 }
174 }
175}
176
178 switch (getDeclKind()) {
179#define DECL(DERIVED, BASE) case Decl::DERIVED: return true;
180#define ABSTRACT_DECL(DECL)
181#include "clang/AST/DeclNodes.inc"
182 }
183 return false;
184}
185
186const char *DeclContext::getDeclKindName() const {
187 switch (getDeclKind()) {
188#define DECL(DERIVED, BASE) case Decl::DERIVED: return #DERIVED;
189#define ABSTRACT_DECL(DECL)
190#include "clang/AST/DeclNodes.inc"
191 }
192 llvm_unreachable("Declaration context not in DeclNodes.inc!");
193}
194
195bool Decl::StatisticsEnabled = false;
197 StatisticsEnabled = true;
198}
199
201 llvm::errs() << "\n*** Decl Stats:\n";
202
203 int totalDecls = 0;
204#define DECL(DERIVED, BASE) totalDecls += n##DERIVED##s;
205#define ABSTRACT_DECL(DECL)
206#include "clang/AST/DeclNodes.inc"
207 llvm::errs() << " " << totalDecls << " decls total.\n";
208
209 int totalBytes = 0;
210#define DECL(DERIVED, BASE) \
211 if (n##DERIVED##s > 0) { \
212 totalBytes += (int)(n##DERIVED##s * sizeof(DERIVED##Decl)); \
213 llvm::errs() << " " << n##DERIVED##s << " " #DERIVED " decls, " \
214 << sizeof(DERIVED##Decl) << " each (" \
215 << n##DERIVED##s * sizeof(DERIVED##Decl) \
216 << " bytes)\n"; \
217 }
218#define ABSTRACT_DECL(DECL)
219#include "clang/AST/DeclNodes.inc"
220
221 llvm::errs() << "Total bytes = " << totalBytes << "\n";
222}
223
225 switch (k) {
226#define DECL(DERIVED, BASE) case DERIVED: ++n##DERIVED##s; break;
227#define ABSTRACT_DECL(DECL)
228#include "clang/AST/DeclNodes.inc"
229 }
230}
231
233 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(this))
234 return TTP->isParameterPack();
235 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(this))
236 return NTTP->isParameterPack();
237 if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(this))
238 return TTP->isParameterPack();
239 return false;
240}
241
243 if (const auto *Var = dyn_cast<VarDecl>(this))
244 return Var->isParameterPack();
245
247}
248
250 if (auto *FD = dyn_cast<FunctionDecl>(this))
251 return FD;
252 if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(this))
253 return FTD->getTemplatedDecl();
254 return nullptr;
255}
256
258 return isa<TemplateDecl>(this);
259}
260
262 if (auto *FD = dyn_cast<FunctionDecl>(this))
263 return FD->getDescribedFunctionTemplate();
264 if (auto *RD = dyn_cast<CXXRecordDecl>(this))
265 return RD->getDescribedClassTemplate();
266 if (auto *VD = dyn_cast<VarDecl>(this))
267 return VD->getDescribedVarTemplate();
268 if (auto *AD = dyn_cast<TypeAliasDecl>(this))
269 return AD->getDescribedAliasTemplate();
270
271 return nullptr;
272}
273
275 if (auto *TD = getDescribedTemplate())
276 return TD->getTemplateParameters();
277 if (auto *CTPSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(this))
278 return CTPSD->getTemplateParameters();
279 if (auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl>(this))
280 return VTPSD->getTemplateParameters();
281 return nullptr;
282}
283
284bool Decl::isTemplated() const {
285 // A declaration is templated if it is a template or a template pattern, or
286 // is within (lexcially for a friend or local function declaration,
287 // semantically otherwise) a dependent context.
288 if (auto *AsDC = dyn_cast<DeclContext>(this))
289 return AsDC->isDependentContext();
290 auto *DC = getFriendObjectKind() || isLocalExternDecl()
292 return DC->isDependentContext() || isTemplateDecl() ||
294}
295
296unsigned Decl::getTemplateDepth() const {
297 if (auto *DC = dyn_cast<DeclContext>(this))
298 if (DC->isFileContext())
299 return 0;
300
301 if (auto *TPL = getDescribedTemplateParams())
302 return TPL->getDepth() + 1;
303
304 // If this is a dependent lambda, there might be an enclosing variable
305 // template. In this case, the next step is not the parent DeclContext (or
306 // even a DeclContext at all).
307 auto *RD = dyn_cast<CXXRecordDecl>(this);
308 if (RD && RD->isDependentLambda())
309 if (Decl *Context = RD->getLambdaContextDecl())
310 return Context->getTemplateDepth();
311
312 const DeclContext *DC =
314 return cast<Decl>(DC)->getTemplateDepth();
315}
316
317const DeclContext *Decl::getParentFunctionOrMethod(bool LexicalParent) const {
318 for (const DeclContext *DC = LexicalParent ? getLexicalDeclContext()
319 : getDeclContext();
320 DC && !DC->isFileContext(); DC = DC->getParent())
321 if (DC->isFunctionOrMethod())
322 return DC;
323
324 return nullptr;
325}
326
327//===----------------------------------------------------------------------===//
328// PrettyStackTraceDecl Implementation
329//===----------------------------------------------------------------------===//
330
331void PrettyStackTraceDecl::print(raw_ostream &OS) const {
332 SourceLocation TheLoc = Loc;
333 if (TheLoc.isInvalid() && TheDecl)
334 TheLoc = TheDecl->getLocation();
335
336 if (TheLoc.isValid()) {
337 TheLoc.print(OS, SM);
338 OS << ": ";
339 }
340
341 OS << Message;
342
343 if (const auto *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) {
344 OS << " '";
345 DN->printQualifiedName(OS);
346 OS << '\'';
347 }
348 OS << '\n';
349}
350
351//===----------------------------------------------------------------------===//
352// Decl Implementation
353//===----------------------------------------------------------------------===//
354
355// Out-of-line virtual method providing a home for Decl.
356Decl::~Decl() = default;
357
359 DeclCtx = DC;
360}
361
363 if (DC == getLexicalDeclContext())
364 return;
365
366 if (isInSemaDC()) {
367 setDeclContextsImpl(getDeclContext(), DC, getASTContext());
368 } else {
369 getMultipleDC()->LexicalDC = DC;
370 }
371
372 // FIXME: We shouldn't be changing the lexical context of declarations
373 // imported from AST files.
374 if (!isFromASTFile()) {
375 setModuleOwnershipKind(getModuleOwnershipKindForChildOf(DC));
376 if (hasOwningModule())
377 setLocalOwningModule(cast<Decl>(DC)->getOwningModule());
378 }
379
380 assert(
382 getOwningModule()) &&
383 "hidden declaration has no owning module");
384}
385
386void Decl::setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC,
387 ASTContext &Ctx) {
388 if (SemaDC == LexicalDC) {
389 DeclCtx = SemaDC;
390 } else {
391 auto *MDC = new (Ctx) Decl::MultipleDC();
392 MDC->SemanticDC = SemaDC;
393 MDC->LexicalDC = LexicalDC;
394 DeclCtx = MDC;
395 }
396}
397
399 const DeclContext *LDC = getLexicalDeclContext();
400 if (!LDC->isDependentContext())
401 return false;
402 while (true) {
403 if (LDC->isFunctionOrMethod())
404 return true;
405 if (!isa<TagDecl>(LDC))
406 return false;
407 if (const auto *CRD = dyn_cast<CXXRecordDecl>(LDC))
408 if (CRD->isLambda())
409 return true;
410 LDC = LDC->getLexicalParent();
411 }
412 return false;
413}
414
416 for (const DeclContext *DC = getDeclContext(); DC; DC = DC->getParent()) {
417 if (const auto *ND = dyn_cast<NamespaceDecl>(DC))
418 if (ND->isAnonymousNamespace())
419 return true;
420 }
421
422 return false;
423}
424
426 const DeclContext *DC = getDeclContext();
427 return DC && DC->getNonTransparentContext()->isStdNamespace();
428}
429
431 const auto *DC = dyn_cast<DeclContext>(this);
432 return DC && DC->isFileContext();
433}
434
436 ASTContext &Ctx, const Decl *D, QualType Ty,
437 LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel,
438 bool IgnoreTemplateOrMacroSubstitution) {
439 // For compatibility with existing code, we treat arrays of length 0 or
440 // 1 as flexible array members.
441 const auto *CAT = Ctx.getAsConstantArrayType(Ty);
442 if (CAT) {
444
445 llvm::APInt Size = CAT->getSize();
446 if (StrictFlexArraysLevel == FAMKind::IncompleteOnly)
447 return false;
448
449 // GCC extension, only allowed to represent a FAM.
450 if (Size.isZero())
451 return true;
452
453 if (StrictFlexArraysLevel == FAMKind::ZeroOrIncomplete && Size.uge(1))
454 return false;
455
456 if (StrictFlexArraysLevel == FAMKind::OneZeroOrIncomplete && Size.uge(2))
457 return false;
458 } else if (!Ctx.getAsIncompleteArrayType(Ty)) {
459 return false;
460 }
461
462 if (const auto *OID = dyn_cast_if_present<ObjCIvarDecl>(D))
463 return OID->getNextIvar() == nullptr;
464
465 const auto *FD = dyn_cast_if_present<FieldDecl>(D);
466 if (!FD)
467 return false;
468
469 if (CAT) {
470 // GCC treats an array memeber of a union as an FAM if the size is one or
471 // zero.
472 llvm::APInt Size = CAT->getSize();
473 if (FD->getParent()->isUnion() && (Size.isZero() || Size.isOne()))
474 return true;
475 }
476
477 // Don't consider sizes resulting from macro expansions or template argument
478 // substitution to form C89 tail-padded arrays.
479 if (IgnoreTemplateOrMacroSubstitution) {
480 TypeSourceInfo *TInfo = FD->getTypeSourceInfo();
481 while (TInfo) {
482 TypeLoc TL = TInfo->getTypeLoc();
483
484 // Look through typedefs.
486 const TypedefNameDecl *TDL = TTL.getTypedefNameDecl();
487 TInfo = TDL->getTypeSourceInfo();
488 continue;
489 }
490
491 if (auto CTL = TL.getAs<ConstantArrayTypeLoc>()) {
492 if (const Expr *SizeExpr =
493 dyn_cast_if_present<IntegerLiteral>(CTL.getSizeExpr());
494 !SizeExpr || SizeExpr->getExprLoc().isMacroID())
495 return false;
496 }
497
498 break;
499 }
500 }
501
502 // Test that the field is the last in the structure.
504 DeclContext::decl_iterator(const_cast<FieldDecl *>(FD)));
505 return ++FI == FD->getParent()->field_end();
506}
507
509 if (auto *TUD = dyn_cast<TranslationUnitDecl>(this))
510 return TUD;
511
513 assert(DC && "This decl is not contained in a translation unit!");
514
515 while (!DC->isTranslationUnit()) {
516 DC = DC->getParent();
517 assert(DC && "This decl is not contained in a translation unit!");
518 }
519
520 return cast<TranslationUnitDecl>(DC);
521}
522
525}
526
527/// Helper to get the language options from the ASTContext.
528/// Defined out of line to avoid depending on ASTContext.h.
530 return getASTContext().getLangOpts();
531}
532
535}
536
537unsigned Decl::getMaxAlignment() const {
538 if (!hasAttrs())
539 return 0;
540
541 unsigned Align = 0;
542 const AttrVec &V = getAttrs();
543 ASTContext &Ctx = getASTContext();
544 specific_attr_iterator<AlignedAttr> I(V.begin()), E(V.end());
545 for (; I != E; ++I) {
546 if (!I->isAlignmentErrorDependent())
547 Align = std::max(Align, I->getAlignment(Ctx));
548 }
549 return Align;
550}
551
552bool Decl::isUsed(bool CheckUsedAttr) const {
553 const Decl *CanonD = getCanonicalDecl();
554 if (CanonD->Used)
555 return true;
556
557 // Check for used attribute.
558 // Ask the most recent decl, since attributes accumulate in the redecl chain.
559 if (CheckUsedAttr && getMostRecentDecl()->hasAttr<UsedAttr>())
560 return true;
561
562 // The information may have not been deserialized yet. Force deserialization
563 // to complete the needed information.
564 return getMostRecentDecl()->getCanonicalDecl()->Used;
565}
566
568 if (isUsed(false))
569 return;
570
571 if (C.getASTMutationListener())
572 C.getASTMutationListener()->DeclarationMarkedUsed(this);
573
574 setIsUsed();
575}
576
577bool Decl::isReferenced() const {
578 if (Referenced)
579 return true;
580
581 // Check redeclarations.
582 for (const auto *I : redecls())
583 if (I->Referenced)
584 return true;
585
586 return false;
587}
588
589ExternalSourceSymbolAttr *Decl::getExternalSourceSymbolAttr() const {
590 const Decl *Definition = nullptr;
591 if (auto *ID = dyn_cast<ObjCInterfaceDecl>(this)) {
592 Definition = ID->getDefinition();
593 } else if (auto *PD = dyn_cast<ObjCProtocolDecl>(this)) {
594 Definition = PD->getDefinition();
595 } else if (auto *TD = dyn_cast<TagDecl>(this)) {
596 Definition = TD->getDefinition();
597 }
598 if (!Definition)
599 Definition = this;
600
601 if (auto *attr = Definition->getAttr<ExternalSourceSymbolAttr>())
602 return attr;
603 if (auto *dcd = dyn_cast<Decl>(getDeclContext())) {
604 return dcd->getAttr<ExternalSourceSymbolAttr>();
605 }
606
607 return nullptr;
608}
609
611 return hasAttr<AliasAttr>() || hasAttr<IFuncAttr>() ||
612 hasAttr<LoaderUninitializedAttr>();
613}
614
616 if (auto *AA = getAttr<AliasAttr>())
617 return AA;
618 if (auto *IFA = getAttr<IFuncAttr>())
619 return IFA;
620 if (auto *NZA = getAttr<LoaderUninitializedAttr>())
621 return NZA;
622 return nullptr;
623}
624
625static StringRef getRealizedPlatform(const AvailabilityAttr *A,
626 const ASTContext &Context) {
627 // Check if this is an App Extension "platform", and if so chop off
628 // the suffix for matching with the actual platform.
629 StringRef RealizedPlatform = A->getPlatform()->getName();
630 if (!Context.getLangOpts().AppExt)
631 return RealizedPlatform;
632 size_t suffix = RealizedPlatform.rfind("_app_extension");
633 if (suffix != StringRef::npos)
634 return RealizedPlatform.slice(0, suffix);
635 return RealizedPlatform;
636}
637
638/// Determine the availability of the given declaration based on
639/// the target platform.
640///
641/// When it returns an availability result other than \c AR_Available,
642/// if the \p Message parameter is non-NULL, it will be set to a
643/// string describing why the entity is unavailable.
644///
645/// FIXME: Make these strings localizable, since they end up in
646/// diagnostics.
648 const AvailabilityAttr *A,
649 std::string *Message,
650 VersionTuple EnclosingVersion) {
651 if (EnclosingVersion.empty())
652 EnclosingVersion = Context.getTargetInfo().getPlatformMinVersion();
653
654 if (EnclosingVersion.empty())
655 return AR_Available;
656
657 StringRef ActualPlatform = A->getPlatform()->getName();
658 StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
659
660 // Match the platform name.
661 if (getRealizedPlatform(A, Context) != TargetPlatform)
662 return AR_Available;
663
664 StringRef PrettyPlatformName
665 = AvailabilityAttr::getPrettyPlatformName(ActualPlatform);
666
667 if (PrettyPlatformName.empty())
668 PrettyPlatformName = ActualPlatform;
669
670 std::string HintMessage;
671 if (!A->getMessage().empty()) {
672 HintMessage = " - ";
673 HintMessage += A->getMessage();
674 }
675
676 // Make sure that this declaration has not been marked 'unavailable'.
677 if (A->getUnavailable()) {
678 if (Message) {
679 Message->clear();
680 llvm::raw_string_ostream Out(*Message);
681 Out << "not available on " << PrettyPlatformName
682 << HintMessage;
683 }
684
685 return AR_Unavailable;
686 }
687
688 // Make sure that this declaration has already been introduced.
689 if (!A->getIntroduced().empty() &&
690 EnclosingVersion < A->getIntroduced()) {
691 IdentifierInfo *IIEnv = A->getEnvironment();
692 StringRef TargetEnv =
693 Context.getTargetInfo().getTriple().getEnvironmentName();
694 StringRef EnvName = llvm::Triple::getEnvironmentTypeName(
695 Context.getTargetInfo().getTriple().getEnvironment());
696 // Matching environment or no environment on attribute
697 if (!IIEnv || (!TargetEnv.empty() && IIEnv->getName() == TargetEnv)) {
698 if (Message) {
699 Message->clear();
700 llvm::raw_string_ostream Out(*Message);
701 VersionTuple VTI(A->getIntroduced());
702 Out << "introduced in " << PrettyPlatformName << " " << VTI << " "
703 << EnvName << HintMessage;
704 }
705 }
706 // Non-matching environment or no environment on target
707 else {
708 if (Message) {
709 Message->clear();
710 llvm::raw_string_ostream Out(*Message);
711 Out << "not available on " << PrettyPlatformName << " " << EnvName
712 << HintMessage;
713 }
714 }
715
716 return A->getStrict() ? AR_Unavailable : AR_NotYetIntroduced;
717 }
718
719 // Make sure that this declaration hasn't been obsoleted.
720 if (!A->getObsoleted().empty() && EnclosingVersion >= A->getObsoleted()) {
721 if (Message) {
722 Message->clear();
723 llvm::raw_string_ostream Out(*Message);
724 VersionTuple VTO(A->getObsoleted());
725 Out << "obsoleted in " << PrettyPlatformName << ' '
726 << VTO << HintMessage;
727 }
728
729 return AR_Unavailable;
730 }
731
732 // Make sure that this declaration hasn't been deprecated.
733 if (!A->getDeprecated().empty() && EnclosingVersion >= A->getDeprecated()) {
734 if (Message) {
735 Message->clear();
736 llvm::raw_string_ostream Out(*Message);
737 VersionTuple VTD(A->getDeprecated());
738 Out << "first deprecated in " << PrettyPlatformName << ' '
739 << VTD << HintMessage;
740 }
741
742 return AR_Deprecated;
743 }
744
745 return AR_Available;
746}
747
749 VersionTuple EnclosingVersion,
750 StringRef *RealizedPlatform) const {
751 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(this))
752 return FTD->getTemplatedDecl()->getAvailability(Message, EnclosingVersion,
753 RealizedPlatform);
754
756 std::string ResultMessage;
757
758 for (const auto *A : attrs()) {
759 if (const auto *Deprecated = dyn_cast<DeprecatedAttr>(A)) {
760 if (Result >= AR_Deprecated)
761 continue;
762
763 if (Message)
764 ResultMessage = std::string(Deprecated->getMessage());
765
767 continue;
768 }
769
770 if (const auto *Unavailable = dyn_cast<UnavailableAttr>(A)) {
771 if (Message)
772 *Message = std::string(Unavailable->getMessage());
773 return AR_Unavailable;
774 }
775
776 if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
778 Message, EnclosingVersion);
779
780 if (AR == AR_Unavailable) {
781 if (RealizedPlatform)
782 *RealizedPlatform = Availability->getPlatform()->getName();
783 return AR_Unavailable;
784 }
785
786 if (AR > Result) {
787 Result = AR;
788 if (Message)
789 ResultMessage.swap(*Message);
790 }
791 continue;
792 }
793 }
794
795 if (Message)
796 Message->swap(ResultMessage);
797 return Result;
798}
799
800VersionTuple Decl::getVersionIntroduced() const {
801 const ASTContext &Context = getASTContext();
802 StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
803 for (const auto *A : attrs()) {
804 if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
805 if (getRealizedPlatform(Availability, Context) != TargetPlatform)
806 continue;
807 if (!Availability->getIntroduced().empty())
808 return Availability->getIntroduced();
809 }
810 }
811 return {};
812}
813
814bool Decl::canBeWeakImported(bool &IsDefinition) const {
815 IsDefinition = false;
816
817 // Variables, if they aren't definitions.
818 if (const auto *Var = dyn_cast<VarDecl>(this)) {
819 if (Var->isThisDeclarationADefinition()) {
820 IsDefinition = true;
821 return false;
822 }
823 return true;
824 }
825 // Functions, if they aren't definitions.
826 if (const auto *FD = dyn_cast<FunctionDecl>(this)) {
827 if (FD->hasBody()) {
828 IsDefinition = true;
829 return false;
830 }
831 return true;
832
833 }
834 // Objective-C classes, if this is the non-fragile runtime.
835 if (isa<ObjCInterfaceDecl>(this) &&
837 return true;
838 }
839 // Nothing else.
840 return false;
841}
842
844 bool IsDefinition;
845 if (!canBeWeakImported(IsDefinition))
846 return false;
847
848 for (const auto *A : getMostRecentDecl()->attrs()) {
849 if (isa<WeakImportAttr>(A))
850 return true;
851
852 if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
853 if (CheckAvailability(getASTContext(), Availability, nullptr,
854 VersionTuple()) == AR_NotYetIntroduced)
855 return true;
856 }
857 }
858
859 return false;
860}
861
863 switch (DeclKind) {
864 case Function:
865 case CXXDeductionGuide:
866 case CXXMethod:
867 case CXXConstructor:
868 case ConstructorUsingShadow:
869 case CXXDestructor:
870 case CXXConversion:
871 case EnumConstant:
872 case Var:
873 case ImplicitParam:
874 case ParmVar:
875 case ObjCMethod:
876 case ObjCProperty:
877 case MSProperty:
878 case HLSLBuffer:
879 return IDNS_Ordinary;
880 case Label:
881 return IDNS_Label;
882 case IndirectField:
883 return IDNS_Ordinary | IDNS_Member;
884
885 case Binding:
886 case NonTypeTemplateParm:
887 case VarTemplate:
888 case Concept:
889 // These (C++-only) declarations are found by redeclaration lookup for
890 // tag types, so we include them in the tag namespace.
891 return IDNS_Ordinary | IDNS_Tag;
892
893 case ObjCCompatibleAlias:
894 case ObjCInterface:
895 return IDNS_Ordinary | IDNS_Type;
896
897 case Typedef:
898 case TypeAlias:
899 case TemplateTypeParm:
900 case ObjCTypeParam:
901 return IDNS_Ordinary | IDNS_Type;
902
903 case UnresolvedUsingTypename:
905
906 case UsingShadow:
907 return 0; // we'll actually overwrite this later
908
909 case UnresolvedUsingValue:
910 return IDNS_Ordinary | IDNS_Using;
911
912 case Using:
913 case UsingPack:
914 case UsingEnum:
915 return IDNS_Using;
916
917 case ObjCProtocol:
918 return IDNS_ObjCProtocol;
919
920 case Field:
921 case ObjCAtDefsField:
922 case ObjCIvar:
923 return IDNS_Member;
924
925 case Record:
926 case CXXRecord:
927 case Enum:
928 return IDNS_Tag | IDNS_Type;
929
930 case Namespace:
931 case NamespaceAlias:
932 return IDNS_Namespace;
933
934 case FunctionTemplate:
935 return IDNS_Ordinary;
936
937 case ClassTemplate:
938 case TemplateTemplateParm:
939 case TypeAliasTemplate:
941
942 case UnresolvedUsingIfExists:
943 return IDNS_Type | IDNS_Ordinary;
944
945 case OMPDeclareReduction:
946 return IDNS_OMPReduction;
947
948 case OMPDeclareMapper:
949 return IDNS_OMPMapper;
950
951 // Never have names.
952 case Friend:
953 case FriendTemplate:
954 case AccessSpec:
955 case LinkageSpec:
956 case Export:
957 case FileScopeAsm:
958 case TopLevelStmt:
959 case StaticAssert:
960 case ObjCPropertyImpl:
961 case PragmaComment:
962 case PragmaDetectMismatch:
963 case Block:
964 case Captured:
965 case TranslationUnit:
966 case ExternCContext:
967 case Decomposition:
968 case MSGuid:
969 case UnnamedGlobalConstant:
970 case TemplateParamObject:
971
972 case UsingDirective:
973 case BuiltinTemplate:
974 case ClassTemplateSpecialization:
975 case ClassTemplatePartialSpecialization:
976 case VarTemplateSpecialization:
977 case VarTemplatePartialSpecialization:
978 case ObjCImplementation:
979 case ObjCCategory:
980 case ObjCCategoryImpl:
981 case Import:
982 case OMPThreadPrivate:
983 case OMPAllocate:
984 case OMPRequires:
985 case OMPCapturedExpr:
986 case Empty:
987 case LifetimeExtendedTemporary:
988 case RequiresExprBody:
989 case ImplicitConceptSpecialization:
990 // Never looked up by name.
991 return 0;
992 }
993
994 llvm_unreachable("Invalid DeclKind!");
995}
996
997void Decl::setAttrsImpl(const AttrVec &attrs, ASTContext &Ctx) {
998 assert(!HasAttrs && "Decl already contains attrs.");
999
1000 AttrVec &AttrBlank = Ctx.getDeclAttrs(this);
1001 assert(AttrBlank.empty() && "HasAttrs was wrong?");
1002
1003 AttrBlank = attrs;
1004 HasAttrs = true;
1005}
1006
1008 if (!HasAttrs) return;
1009
1010 HasAttrs = false;
1012}
1013
1015 if (!hasAttrs()) {
1016 setAttrs(AttrVec(1, A));
1017 return;
1018 }
1019
1020 AttrVec &Attrs = getAttrs();
1021 if (!A->isInherited()) {
1022 Attrs.push_back(A);
1023 return;
1024 }
1025
1026 // Attribute inheritance is processed after attribute parsing. To keep the
1027 // order as in the source code, add inherited attributes before non-inherited
1028 // ones.
1029 auto I = Attrs.begin(), E = Attrs.end();
1030 for (; I != E; ++I) {
1031 if (!(*I)->isInherited())
1032 break;
1033 }
1034 Attrs.insert(I, A);
1035}
1036
1037const AttrVec &Decl::getAttrs() const {
1038 assert(HasAttrs && "No attrs to get!");
1039 return getASTContext().getDeclAttrs(this);
1040}
1041
1043 Decl::Kind DK = D->getDeclKind();
1044 switch (DK) {
1045#define DECL(NAME, BASE)
1046#define DECL_CONTEXT(NAME) \
1047 case Decl::NAME: \
1048 return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D));
1049#include "clang/AST/DeclNodes.inc"
1050 default:
1051 llvm_unreachable("a decl that inherits DeclContext isn't handled");
1052 }
1053}
1054
1056 Decl::Kind DK = D->getKind();
1057 switch(DK) {
1058#define DECL(NAME, BASE)
1059#define DECL_CONTEXT(NAME) \
1060 case Decl::NAME: \
1061 return static_cast<NAME##Decl *>(const_cast<Decl *>(D));
1062#include "clang/AST/DeclNodes.inc"
1063 default:
1064 llvm_unreachable("a decl that inherits DeclContext isn't handled");
1065 }
1066}
1067
1069 // Special handling of FunctionDecl to avoid de-serializing the body from PCH.
1070 // FunctionDecl stores EndRangeLoc for this purpose.
1071 if (const auto *FD = dyn_cast<FunctionDecl>(this)) {
1072 const FunctionDecl *Definition;
1073 if (FD->hasBody(Definition))
1074 return Definition->getSourceRange().getEnd();
1075 return {};
1076 }
1077
1078 if (Stmt *Body = getBody())
1079 return Body->getSourceRange().getEnd();
1080
1081 return {};
1082}
1083
1084bool Decl::AccessDeclContextCheck() const {
1085#ifndef NDEBUG
1086 // Suppress this check if any of the following hold:
1087 // 1. this is the translation unit (and thus has no parent)
1088 // 2. this is a template parameter (and thus doesn't belong to its context)
1089 // 3. this is a non-type template parameter
1090 // 4. the context is not a record
1091 // 5. it's invalid
1092 // 6. it's a C++0x static_assert.
1093 // 7. it's a block literal declaration
1094 // 8. it's a temporary with lifetime extended due to being default value.
1095 if (isa<TranslationUnitDecl>(this) || isa<TemplateTypeParmDecl>(this) ||
1096 isa<NonTypeTemplateParmDecl>(this) || !getDeclContext() ||
1097 !isa<CXXRecordDecl>(getDeclContext()) || isInvalidDecl() ||
1098 isa<StaticAssertDecl>(this) || isa<BlockDecl>(this) ||
1099 // FIXME: a ParmVarDecl can have ClassTemplateSpecialization
1100 // as DeclContext (?).
1101 isa<ParmVarDecl>(this) ||
1102 // FIXME: a ClassTemplateSpecialization or CXXRecordDecl can have
1103 // AS_none as access specifier.
1104 isa<CXXRecordDecl>(this) || isa<LifetimeExtendedTemporaryDecl>(this))
1105 return true;
1106
1107 assert(Access != AS_none &&
1108 "Access specifier is AS_none inside a record decl");
1109#endif
1110 return true;
1111}
1112
1114 const DeclContext *DC = getLexicalDeclContext();
1115
1116 while (DC && !isa<ExportDecl>(DC))
1117 DC = DC->getLexicalParent();
1118
1119 return isa_and_nonnull<ExportDecl>(DC);
1120}
1121
1123 auto *M = getOwningModule();
1124
1125 if (!M)
1126 return false;
1127
1128 M = M->getTopLevelModule();
1129 // FIXME: It is problematic if the header module lives in another module
1130 // unit. Consider to fix this by techniques like
1131 // ExternalASTSource::hasExternalDefinitions.
1132 if (M->isHeaderLikeModule())
1133 return false;
1134
1135 // A global module without parent implies that we're parsing the global
1136 // module. So it can't be in another module unit.
1137 if (M->isGlobalModule())
1138 return false;
1139
1140 assert(M->isNamedModule() && "New module kind?");
1141 return M != getASTContext().getCurrentNamedModule();
1142}
1143
1146}
1147
1150}
1151
1152static Decl::Kind getKind(const Decl *D) { return D->getKind(); }
1153static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); }
1154
1155int64_t Decl::getID() const {
1156 return getASTContext().getAllocator().identifyKnownAlignedObject<Decl>(this);
1157}
1158
1159const FunctionType *Decl::getFunctionType(bool BlocksToo) const {
1160 QualType Ty;
1161 if (isa<BindingDecl>(this))
1162 return nullptr;
1163 else if (const auto *D = dyn_cast<ValueDecl>(this))
1164 Ty = D->getType();
1165 else if (const auto *D = dyn_cast<TypedefNameDecl>(this))
1166 Ty = D->getUnderlyingType();
1167 else
1168 return nullptr;
1169
1170 if (Ty->isFunctionPointerType())
1171 Ty = Ty->castAs<PointerType>()->getPointeeType();
1172 else if (Ty->isFunctionReferenceType())
1173 Ty = Ty->castAs<ReferenceType>()->getPointeeType();
1174 else if (BlocksToo && Ty->isBlockPointerType())
1175 Ty = Ty->castAs<BlockPointerType>()->getPointeeType();
1176
1177 return Ty->getAs<FunctionType>();
1178}
1179
1181 QualType Ty;
1182 if (const auto *D = dyn_cast<ValueDecl>(this))
1183 Ty = D->getType();
1184 else if (const auto *D = dyn_cast<TypedefNameDecl>(this))
1185 Ty = D->getUnderlyingType();
1186 else
1187 return false;
1188
1190}
1191
1193 assert(getDeclContext());
1195}
1196
1197/// Starting at a given context (a Decl or DeclContext), look for a
1198/// code context that is not a closure (a lambda, block, etc.).
1199template <class T> static Decl *getNonClosureContext(T *D) {
1200 if (getKind(D) == Decl::CXXMethod) {
1201 auto *MD = cast<CXXMethodDecl>(D);
1202 if (MD->getOverloadedOperator() == OO_Call &&
1203 MD->getParent()->isLambda())
1204 return getNonClosureContext(MD->getParent()->getParent());
1205 return MD;
1206 }
1207 if (auto *FD = dyn_cast<FunctionDecl>(D))
1208 return FD;
1209 if (auto *MD = dyn_cast<ObjCMethodDecl>(D))
1210 return MD;
1211 if (auto *BD = dyn_cast<BlockDecl>(D))
1212 return getNonClosureContext(BD->getParent());
1213 if (auto *CD = dyn_cast<CapturedDecl>(D))
1214 return getNonClosureContext(CD->getParent());
1215 return nullptr;
1216}
1217
1219 return ::getNonClosureContext(this);
1220}
1221
1223 return ::getNonClosureContext(this);
1224}
1225
1226//===----------------------------------------------------------------------===//
1227// DeclContext Implementation
1228//===----------------------------------------------------------------------===//
1229
1231 DeclContextBits.DeclKind = K;
1234 setNeedToReconcileExternalVisibleStorage(false);
1235 setHasLazyLocalLexicalLookups(false);
1236 setHasLazyExternalLexicalLookups(false);
1237 setUseQualifiedLookup(false);
1238}
1239
1241 Decl::Kind DK = D->getKind();
1242 switch (DK) {
1243#define DECL(NAME, BASE)
1244#define DECL_CONTEXT(NAME) case Decl::NAME:
1245#include "clang/AST/DeclNodes.inc"
1246 return true;
1247 default:
1248 return false;
1249 }
1250}
1251
1252DeclContext::~DeclContext() = default;
1253
1254/// Find the parent context of this context that will be
1255/// used for unqualified name lookup.
1256///
1257/// Generally, the parent lookup context is the semantic context. However, for
1258/// a friend function the parent lookup context is the lexical context, which
1259/// is the class in which the friend is declared.
1261 // FIXME: Find a better way to identify friends.
1262 if (isa<FunctionDecl>(this))
1265 return getLexicalParent();
1266
1267 // A lookup within the call operator of a lambda never looks in the lambda
1268 // class; instead, skip to the context in which that closure type is
1269 // declared.
1270 if (isLambdaCallOperator(this))
1271 return getParent()->getParent();
1272
1273 return getParent();
1274}
1275
1277 const DeclContext *Ctx = this;
1278
1279 do {
1280 if (Ctx->isClosure())
1281 return cast<BlockDecl>(Ctx);
1282 Ctx = Ctx->getParent();
1283 } while (Ctx);
1284
1285 return nullptr;
1286}
1287
1289 return isNamespace() &&
1290 cast<NamespaceDecl>(this)->isInline();
1291}
1292
1294 if (!isNamespace())
1295 return false;
1296
1297 const auto *ND = cast<NamespaceDecl>(this);
1298 if (ND->isInline()) {
1299 return ND->getParent()->isStdNamespace();
1300 }
1301
1303 return false;
1304
1305 const IdentifierInfo *II = ND->getIdentifier();
1306 return II && II->isStr("std");
1307}
1308
1310 if (isFileContext())
1311 return false;
1312
1313 if (isa<ClassTemplatePartialSpecializationDecl>(this))
1314 return true;
1315
1316 if (const auto *Record = dyn_cast<CXXRecordDecl>(this)) {
1317 if (Record->getDescribedClassTemplate())
1318 return true;
1319
1320 if (Record->isDependentLambda())
1321 return true;
1322 if (Record->isNeverDependentLambda())
1323 return false;
1324 }
1325
1326 if (const auto *Function = dyn_cast<FunctionDecl>(this)) {
1327 if (Function->getDescribedFunctionTemplate())
1328 return true;
1329
1330 // Friend function declarations are dependent if their *lexical*
1331 // context is dependent.
1332 if (cast<Decl>(this)->getFriendObjectKind())
1334 }
1335
1336 // FIXME: A variable template is a dependent context, but is not a
1337 // DeclContext. A context within it (such as a lambda-expression)
1338 // should be considered dependent.
1339
1340 return getParent() && getParent()->isDependentContext();
1341}
1342
1344 if (getDeclKind() == Decl::Enum)
1345 return !cast<EnumDecl>(this)->isScoped();
1346
1347 return isa<LinkageSpecDecl, ExportDecl, HLSLBufferDecl>(this);
1348}
1349
1350static bool isLinkageSpecContext(const DeclContext *DC,
1352 while (DC->getDeclKind() != Decl::TranslationUnit) {
1353 if (DC->getDeclKind() == Decl::LinkageSpec)
1354 return cast<LinkageSpecDecl>(DC)->getLanguage() == ID;
1355 DC = DC->getLexicalParent();
1356 }
1357 return false;
1358}
1359
1362}
1363
1365 const DeclContext *DC = this;
1366 while (DC->getDeclKind() != Decl::TranslationUnit) {
1367 if (DC->getDeclKind() == Decl::LinkageSpec &&
1368 cast<LinkageSpecDecl>(DC)->getLanguage() == LinkageSpecLanguageIDs::C)
1369 return cast<LinkageSpecDecl>(DC);
1370 DC = DC->getLexicalParent();
1371 }
1372 return nullptr;
1373}
1374
1377}
1378
1379bool DeclContext::Encloses(const DeclContext *DC) const {
1380 if (getPrimaryContext() != this)
1381 return getPrimaryContext()->Encloses(DC);
1382
1383 for (; DC; DC = DC->getParent())
1384 if (!isa<LinkageSpecDecl>(DC) && !isa<ExportDecl>(DC) &&
1385 DC->getPrimaryContext() == this)
1386 return true;
1387 return false;
1388}
1389
1391 DeclContext *DC = this;
1392 while (DC->isTransparentContext()) {
1393 DC = DC->getParent();
1394 assert(DC && "All transparent contexts should have a parent!");
1395 }
1396 return DC;
1397}
1398
1400 switch (getDeclKind()) {
1401 case Decl::ExternCContext:
1402 case Decl::LinkageSpec:
1403 case Decl::Export:
1404 case Decl::TopLevelStmt:
1405 case Decl::Block:
1406 case Decl::Captured:
1407 case Decl::OMPDeclareReduction:
1408 case Decl::OMPDeclareMapper:
1409 case Decl::RequiresExprBody:
1410 // There is only one DeclContext for these entities.
1411 return this;
1412
1413 case Decl::HLSLBuffer:
1414 // Each buffer, even with the same name, is a distinct construct.
1415 // Multiple buffers with the same name are allowed for backward
1416 // compatibility.
1417 // As long as buffers have unique resource bindings the names don't matter.
1418 // The names get exposed via the CPU-side reflection API which
1419 // supports querying bindings, so we cannot remove them.
1420 return this;
1421
1422 case Decl::TranslationUnit:
1423 return static_cast<TranslationUnitDecl *>(this)->getFirstDecl();
1424 case Decl::Namespace:
1425 // The original namespace is our primary context.
1426 return static_cast<NamespaceDecl *>(this)->getOriginalNamespace();
1427
1428 case Decl::ObjCMethod:
1429 return this;
1430
1431 case Decl::ObjCInterface:
1432 if (auto *OID = dyn_cast<ObjCInterfaceDecl>(this))
1433 if (auto *Def = OID->getDefinition())
1434 return Def;
1435 return this;
1436
1437 case Decl::ObjCProtocol:
1438 if (auto *OPD = dyn_cast<ObjCProtocolDecl>(this))
1439 if (auto *Def = OPD->getDefinition())
1440 return Def;
1441 return this;
1442
1443 case Decl::ObjCCategory:
1444 return this;
1445
1446 case Decl::ObjCImplementation:
1447 case Decl::ObjCCategoryImpl:
1448 return this;
1449
1450 default:
1451 if (getDeclKind() >= Decl::firstTag && getDeclKind() <= Decl::lastTag) {
1452 // If this is a tag type that has a definition or is currently
1453 // being defined, that definition is our primary context.
1454 auto *Tag = cast<TagDecl>(this);
1455
1456 if (TagDecl *Def = Tag->getDefinition())
1457 return Def;
1458
1459 if (const auto *TagTy = dyn_cast<TagType>(Tag->getTypeForDecl())) {
1460 // Note, TagType::getDecl returns the (partial) definition one exists.
1461 TagDecl *PossiblePartialDef = TagTy->getDecl();
1462 if (PossiblePartialDef->isBeingDefined())
1463 return PossiblePartialDef;
1464 } else {
1465 assert(isa<InjectedClassNameType>(Tag->getTypeForDecl()));
1466 }
1467
1468 return Tag;
1469 }
1470
1471 assert(getDeclKind() >= Decl::firstFunction &&
1472 getDeclKind() <= Decl::lastFunction &&
1473 "Unknown DeclContext kind");
1474 return this;
1475 }
1476}
1477
1478template <typename T>
1480 for (T *D = Self->getMostRecentDecl(); D; D = D->getPreviousDecl())
1481 Contexts.push_back(D);
1482
1483 std::reverse(Contexts.begin(), Contexts.end());
1484}
1485
1487 Contexts.clear();
1488
1489 Decl::Kind Kind = getDeclKind();
1490
1491 if (Kind == Decl::TranslationUnit)
1492 collectAllContextsImpl(static_cast<TranslationUnitDecl *>(this), Contexts);
1493 else if (Kind == Decl::Namespace)
1494 collectAllContextsImpl(static_cast<NamespaceDecl *>(this), Contexts);
1495 else
1496 Contexts.push_back(this);
1497}
1498
1499std::pair<Decl *, Decl *>
1501 bool FieldsAlreadyLoaded) {
1502 // Build up a chain of declarations via the Decl::NextInContextAndBits field.
1503 Decl *FirstNewDecl = nullptr;
1504 Decl *PrevDecl = nullptr;
1505 for (auto *D : Decls) {
1506 if (FieldsAlreadyLoaded && isa<FieldDecl>(D))
1507 continue;
1508
1509 if (PrevDecl)
1510 PrevDecl->NextInContextAndBits.setPointer(D);
1511 else
1512 FirstNewDecl = D;
1513
1514 PrevDecl = D;
1515 }
1516
1517 return std::make_pair(FirstNewDecl, PrevDecl);
1518}
1519
1520/// We have just acquired external visible storage, and we already have
1521/// built a lookup map. For every name in the map, pull in the new names from
1522/// the external storage.
1523void DeclContext::reconcileExternalVisibleStorage() const {
1524 assert(hasNeedToReconcileExternalVisibleStorage() && LookupPtr);
1525 setNeedToReconcileExternalVisibleStorage(false);
1526
1527 for (auto &Lookup : *LookupPtr)
1528 Lookup.second.setHasExternalDecls();
1529}
1530
1531/// Load the declarations within this lexical storage from an
1532/// external source.
1533/// \return \c true if any declarations were added.
1534bool
1535DeclContext::LoadLexicalDeclsFromExternalStorage() const {
1537 assert(hasExternalLexicalStorage() && Source && "No external storage?");
1538
1539 // Notify that we have a DeclContext that is initializing.
1540 ExternalASTSource::Deserializing ADeclContext(Source);
1541
1542 // Load the external declarations, if any.
1545 Source->FindExternalLexicalDecls(this, Decls);
1546
1547 if (Decls.empty())
1548 return false;
1549
1550 // We may have already loaded just the fields of this record, in which case
1551 // we need to ignore them.
1552 bool FieldsAlreadyLoaded = false;
1553 if (const auto *RD = dyn_cast<RecordDecl>(this))
1554 FieldsAlreadyLoaded = RD->hasLoadedFieldsFromExternalStorage();
1555
1556 // Splice the newly-read declarations into the beginning of the list
1557 // of declarations.
1558 Decl *ExternalFirst, *ExternalLast;
1559 std::tie(ExternalFirst, ExternalLast) =
1560 BuildDeclChain(Decls, FieldsAlreadyLoaded);
1561 ExternalLast->NextInContextAndBits.setPointer(FirstDecl);
1562 FirstDecl = ExternalFirst;
1563 if (!LastDecl)
1564 LastDecl = ExternalLast;
1565 return true;
1566}
1567
1570 DeclarationName Name) {
1571 ASTContext &Context = DC->getParentASTContext();
1572 StoredDeclsMap *Map;
1573 if (!(Map = DC->LookupPtr))
1574 Map = DC->CreateStoredDeclsMap(Context);
1575 if (DC->hasNeedToReconcileExternalVisibleStorage())
1576 DC->reconcileExternalVisibleStorage();
1577
1578 (*Map)[Name].removeExternalDecls();
1579
1581}
1582
1585 DeclarationName Name,
1586 ArrayRef<NamedDecl*> Decls) {
1587 ASTContext &Context = DC->getParentASTContext();
1588 StoredDeclsMap *Map;
1589 if (!(Map = DC->LookupPtr))
1590 Map = DC->CreateStoredDeclsMap(Context);
1591 if (DC->hasNeedToReconcileExternalVisibleStorage())
1592 DC->reconcileExternalVisibleStorage();
1593
1594 StoredDeclsList &List = (*Map)[Name];
1595 List.replaceExternalDecls(Decls);
1596 return List.getLookupResult();
1597}
1598
1601 LoadLexicalDeclsFromExternalStorage();
1602 return decl_iterator(FirstDecl);
1603}
1604
1607 LoadLexicalDeclsFromExternalStorage();
1608
1609 return !FirstDecl;
1610}
1611
1613 return (D->getLexicalDeclContext() == this &&
1614 (D->NextInContextAndBits.getPointer() || D == LastDecl));
1615}
1616
1619 LoadLexicalDeclsFromExternalStorage();
1620 return containsDecl(D);
1621}
1622
1623/// shouldBeHidden - Determine whether a declaration which was declared
1624/// within its semantic context should be invisible to qualified name lookup.
1626 // Skip unnamed declarations.
1627 if (!D->getDeclName())
1628 return true;
1629
1630 // Skip entities that can't be found by name lookup into a particular
1631 // context.
1632 if ((D->getIdentifierNamespace() == 0 && !isa<UsingDirectiveDecl>(D)) ||
1634 return true;
1635
1636 // Skip friends and local extern declarations unless they're the first
1637 // declaration of the entity.
1638 if ((D->isLocalExternDecl() || D->getFriendObjectKind()) &&
1639 D != D->getCanonicalDecl())
1640 return true;
1641
1642 // Skip template specializations.
1643 // FIXME: This feels like a hack. Should DeclarationName support
1644 // template-ids, or is there a better way to keep specializations
1645 // from being visible?
1646 if (isa<ClassTemplateSpecializationDecl>(D))
1647 return true;
1648 if (auto *FD = dyn_cast<FunctionDecl>(D))
1649 if (FD->isFunctionTemplateSpecialization())
1650 return true;
1651
1652 // Hide destructors that are invalid. There should always be one destructor,
1653 // but if it is an invalid decl, another one is created. We need to hide the
1654 // invalid one from places that expect exactly one destructor, like the
1655 // serialization code.
1656 if (isa<CXXDestructorDecl>(D) && D->isInvalidDecl())
1657 return true;
1658
1659 return false;
1660}
1661
1663 assert(D->getLexicalDeclContext() == this &&
1664 "decl being removed from non-lexical context");
1665 assert((D->NextInContextAndBits.getPointer() || D == LastDecl) &&
1666 "decl is not in decls list");
1667
1668 // Remove D from the decl chain. This is O(n) but hopefully rare.
1669 if (D == FirstDecl) {
1670 if (D == LastDecl)
1671 FirstDecl = LastDecl = nullptr;
1672 else
1673 FirstDecl = D->NextInContextAndBits.getPointer();
1674 } else {
1675 for (Decl *I = FirstDecl; true; I = I->NextInContextAndBits.getPointer()) {
1676 assert(I && "decl not found in linked list");
1677 if (I->NextInContextAndBits.getPointer() == D) {
1678 I->NextInContextAndBits.setPointer(D->NextInContextAndBits.getPointer());
1679 if (D == LastDecl) LastDecl = I;
1680 break;
1681 }
1682 }
1683 }
1684
1685 // Mark that D is no longer in the decl chain.
1686 D->NextInContextAndBits.setPointer(nullptr);
1687
1688 // Remove D from the lookup table if necessary.
1689 if (isa<NamedDecl>(D)) {
1690 auto *ND = cast<NamedDecl>(D);
1691
1692 // Do not try to remove the declaration if that is invisible to qualified
1693 // lookup. E.g. template specializations are skipped.
1694 if (shouldBeHidden(ND))
1695 return;
1696
1697 // Remove only decls that have a name
1698 if (!ND->getDeclName())
1699 return;
1700
1701 auto *DC = D->getDeclContext();
1702 do {
1703 StoredDeclsMap *Map = DC->getPrimaryContext()->LookupPtr;
1704 if (Map) {
1705 StoredDeclsMap::iterator Pos = Map->find(ND->getDeclName());
1706 assert(Pos != Map->end() && "no lookup entry for decl");
1707 StoredDeclsList &List = Pos->second;
1708 List.remove(ND);
1709 // Clean up the entry if there are no more decls.
1710 if (List.isNull())
1711 Map->erase(Pos);
1712 }
1713 } while (DC->isTransparentContext() && (DC = DC->getParent()));
1714 }
1715}
1716
1718 assert(D->getLexicalDeclContext() == this &&
1719 "Decl inserted into wrong lexical context");
1720 assert(!D->getNextDeclInContext() && D != LastDecl &&
1721 "Decl already inserted into a DeclContext");
1722
1723 if (FirstDecl) {
1724 LastDecl->NextInContextAndBits.setPointer(D);
1725 LastDecl = D;
1726 } else {
1727 FirstDecl = LastDecl = D;
1728 }
1729
1730 // Notify a C++ record declaration that we've added a member, so it can
1731 // update its class-specific state.
1732 if (auto *Record = dyn_cast<CXXRecordDecl>(this))
1733 Record->addedMember(D);
1734
1735 // If this is a newly-created (not de-serialized) import declaration, wire
1736 // it in to the list of local import declarations.
1737 if (!D->isFromASTFile()) {
1738 if (auto *Import = dyn_cast<ImportDecl>(D))
1740 }
1741}
1742
1745
1746 if (auto *ND = dyn_cast<NamedDecl>(D))
1747 ND->getDeclContext()->getPrimaryContext()->
1748 makeDeclVisibleInContextWithFlags(ND, false, true);
1749}
1750
1753
1754 if (auto *ND = dyn_cast<NamedDecl>(D))
1755 ND->getDeclContext()->getPrimaryContext()->
1756 makeDeclVisibleInContextWithFlags(ND, true, true);
1757}
1758
1759/// buildLookup - Build the lookup data structure with all of the
1760/// declarations in this DeclContext (and any other contexts linked
1761/// to it or transparent contexts nested within it) and return it.
1762///
1763/// Note that the produced map may miss out declarations from an
1764/// external source. If it does, those entries will be marked with
1765/// the 'hasExternalDecls' flag.
1767 assert(this == getPrimaryContext() && "buildLookup called on non-primary DC");
1768
1769 if (!hasLazyLocalLexicalLookups() &&
1770 !hasLazyExternalLexicalLookups())
1771 return LookupPtr;
1772
1774 collectAllContexts(Contexts);
1775
1776 if (hasLazyExternalLexicalLookups()) {
1777 setHasLazyExternalLexicalLookups(false);
1778 for (auto *DC : Contexts) {
1779 if (DC->hasExternalLexicalStorage()) {
1780 bool LoadedDecls = DC->LoadLexicalDeclsFromExternalStorage();
1781 setHasLazyLocalLexicalLookups(
1782 hasLazyLocalLexicalLookups() | LoadedDecls );
1783 }
1784 }
1785
1786 if (!hasLazyLocalLexicalLookups())
1787 return LookupPtr;
1788 }
1789
1790 for (auto *DC : Contexts)
1791 buildLookupImpl(DC, hasExternalVisibleStorage());
1792
1793 // We no longer have any lazy decls.
1794 setHasLazyLocalLexicalLookups(false);
1795 return LookupPtr;
1796}
1797
1798/// buildLookupImpl - Build part of the lookup data structure for the
1799/// declarations contained within DCtx, which will either be this
1800/// DeclContext, a DeclContext linked to it, or a transparent context
1801/// nested within it.
1802void DeclContext::buildLookupImpl(DeclContext *DCtx, bool Internal) {
1803 for (auto *D : DCtx->noload_decls()) {
1804 // Insert this declaration into the lookup structure, but only if
1805 // it's semantically within its decl context. Any other decls which
1806 // should be found in this context are added eagerly.
1807 //
1808 // If it's from an AST file, don't add it now. It'll get handled by
1809 // FindExternalVisibleDeclsByName if needed. Exception: if we're not
1810 // in C++, we do not track external visible decls for the TU, so in
1811 // that case we need to collect them all here.
1812 if (auto *ND = dyn_cast<NamedDecl>(D))
1813 if (ND->getDeclContext() == DCtx && !shouldBeHidden(ND) &&
1814 (!ND->isFromASTFile() ||
1815 (isTranslationUnit() &&
1816 !getParentASTContext().getLangOpts().CPlusPlus)))
1817 makeDeclVisibleInContextImpl(ND, Internal);
1818
1819 // If this declaration is itself a transparent declaration context
1820 // or inline namespace, add the members of this declaration of that
1821 // context (recursively).
1822 if (auto *InnerCtx = dyn_cast<DeclContext>(D))
1823 if (InnerCtx->isTransparentContext() || InnerCtx->isInlineNamespace())
1824 buildLookupImpl(InnerCtx, Internal);
1825 }
1826}
1827
1830 // For transparent DeclContext, we should lookup in their enclosing context.
1831 if (getDeclKind() == Decl::LinkageSpec || getDeclKind() == Decl::Export)
1832 return getParent()->lookup(Name);
1833
1834 const DeclContext *PrimaryContext = getPrimaryContext();
1835 if (PrimaryContext != this)
1836 return PrimaryContext->lookup(Name);
1837
1838 // If we have an external source, ensure that any later redeclarations of this
1839 // context have been loaded, since they may add names to the result of this
1840 // lookup (or add external visible storage).
1842 if (Source)
1843 (void)cast<Decl>(this)->getMostRecentDecl();
1844
1846 assert(Source && "external visible storage but no external source?");
1847
1848 if (hasNeedToReconcileExternalVisibleStorage())
1849 reconcileExternalVisibleStorage();
1850
1851 StoredDeclsMap *Map = LookupPtr;
1852
1853 if (hasLazyLocalLexicalLookups() ||
1854 hasLazyExternalLexicalLookups())
1855 // FIXME: Make buildLookup const?
1856 Map = const_cast<DeclContext*>(this)->buildLookup();
1857
1858 if (!Map)
1859 Map = CreateStoredDeclsMap(getParentASTContext());
1860
1861 // If we have a lookup result with no external decls, we are done.
1862 std::pair<StoredDeclsMap::iterator, bool> R =
1863 Map->insert(std::make_pair(Name, StoredDeclsList()));
1864 if (!R.second && !R.first->second.hasExternalDecls())
1865 return R.first->second.getLookupResult();
1866
1867 if (Source->FindExternalVisibleDeclsByName(this, Name) || !R.second) {
1868 if (StoredDeclsMap *Map = LookupPtr) {
1869 StoredDeclsMap::iterator I = Map->find(Name);
1870 if (I != Map->end())
1871 return I->second.getLookupResult();
1872 }
1873 }
1874
1875 return {};
1876 }
1877
1878 StoredDeclsMap *Map = LookupPtr;
1879 if (hasLazyLocalLexicalLookups() ||
1880 hasLazyExternalLexicalLookups())
1881 Map = const_cast<DeclContext*>(this)->buildLookup();
1882
1883 if (!Map)
1884 return {};
1885
1886 StoredDeclsMap::iterator I = Map->find(Name);
1887 if (I == Map->end())
1888 return {};
1889
1890 return I->second.getLookupResult();
1891}
1892
1895 // For transparent DeclContext, we should lookup in their enclosing context.
1896 if (getDeclKind() == Decl::LinkageSpec || getDeclKind() == Decl::Export)
1897 return getParent()->noload_lookup(Name);
1898
1899 DeclContext *PrimaryContext = getPrimaryContext();
1900 if (PrimaryContext != this)
1901 return PrimaryContext->noload_lookup(Name);
1902
1903 loadLazyLocalLexicalLookups();
1904 StoredDeclsMap *Map = LookupPtr;
1905 if (!Map)
1906 return {};
1907
1908 StoredDeclsMap::iterator I = Map->find(Name);
1909 return I != Map->end() ? I->second.getLookupResult()
1910 : lookup_result();
1911}
1912
1913// If we have any lazy lexical declarations not in our lookup map, add them
1914// now. Don't import any external declarations, not even if we know we have
1915// some missing from the external visible lookups.
1916void DeclContext::loadLazyLocalLexicalLookups() {
1917 if (hasLazyLocalLexicalLookups()) {
1919 collectAllContexts(Contexts);
1920 for (auto *Context : Contexts)
1921 buildLookupImpl(Context, hasExternalVisibleStorage());
1922 setHasLazyLocalLexicalLookups(false);
1923 }
1924}
1925
1928 Results.clear();
1929
1930 // If there's no external storage, just perform a normal lookup and copy
1931 // the results.
1933 lookup_result LookupResults = lookup(Name);
1934 Results.insert(Results.end(), LookupResults.begin(), LookupResults.end());
1935 if (!Results.empty())
1936 return;
1937 }
1938
1939 // If we have a lookup table, check there first. Maybe we'll get lucky.
1940 // FIXME: Should we be checking these flags on the primary context?
1941 if (Name && !hasLazyLocalLexicalLookups() &&
1942 !hasLazyExternalLexicalLookups()) {
1943 if (StoredDeclsMap *Map = LookupPtr) {
1944 StoredDeclsMap::iterator Pos = Map->find(Name);
1945 if (Pos != Map->end()) {
1946 Results.insert(Results.end(),
1947 Pos->second.getLookupResult().begin(),
1948 Pos->second.getLookupResult().end());
1949 return;
1950 }
1951 }
1952 }
1953
1954 // Slow case: grovel through the declarations in our chain looking for
1955 // matches.
1956 // FIXME: If we have lazy external declarations, this will not find them!
1957 // FIXME: Should we CollectAllContexts and walk them all here?
1958 for (Decl *D = FirstDecl; D; D = D->getNextDeclInContext()) {
1959 if (auto *ND = dyn_cast<NamedDecl>(D))
1960 if (ND->getDeclName() == Name)
1961 Results.push_back(ND);
1962 }
1963}
1964
1966 DeclContext *Ctx = this;
1967
1968 // In C, a record type is the redeclaration context for its fields only. If
1969 // we arrive at a record context after skipping anything else, we should skip
1970 // the record as well. Currently, this means skipping enumerations because
1971 // they're the only transparent context that can exist within a struct or
1972 // union.
1973 bool SkipRecords = getDeclKind() == Decl::Kind::Enum &&
1974 !getParentASTContext().getLangOpts().CPlusPlus;
1975
1976 // Skip through contexts to get to the redeclaration context. Transparent
1977 // contexts are always skipped.
1978 while ((SkipRecords && Ctx->isRecord()) || Ctx->isTransparentContext())
1979 Ctx = Ctx->getParent();
1980 return Ctx;
1981}
1982
1984 DeclContext *Ctx = this;
1985 // Skip through non-namespace, non-translation-unit contexts.
1986 while (!Ctx->isFileContext())
1987 Ctx = Ctx->getParent();
1988 return Ctx->getPrimaryContext();
1989}
1990
1992 // Loop until we find a non-record context.
1993 RecordDecl *OutermostRD = nullptr;
1994 DeclContext *DC = this;
1995 while (DC->isRecord()) {
1996 OutermostRD = cast<RecordDecl>(DC);
1997 DC = DC->getLexicalParent();
1998 }
1999 return OutermostRD;
2000}
2001
2003 // For non-file contexts, this is equivalent to Equals.
2004 if (!isFileContext())
2005 return O->Equals(this);
2006
2007 do {
2008 if (O->Equals(this))
2009 return true;
2010
2011 const auto *NS = dyn_cast<NamespaceDecl>(O);
2012 if (!NS || !NS->isInline())
2013 break;
2014 O = NS->getParent();
2015 } while (O);
2016
2017 return false;
2018}
2019
2021 DeclContext *PrimaryDC = this->getPrimaryContext();
2023 // If the decl is being added outside of its semantic decl context, we
2024 // need to ensure that we eagerly build the lookup information for it.
2025 PrimaryDC->makeDeclVisibleInContextWithFlags(D, false, PrimaryDC == DeclDC);
2026}
2027
2028void DeclContext::makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,
2029 bool Recoverable) {
2030 assert(this == getPrimaryContext() && "expected a primary DC");
2031
2032 if (!isLookupContext()) {
2035 ->makeDeclVisibleInContextWithFlags(D, Internal, Recoverable);
2036 return;
2037 }
2038
2039 // Skip declarations which should be invisible to name lookup.
2040 if (shouldBeHidden(D))
2041 return;
2042
2043 // If we already have a lookup data structure, perform the insertion into
2044 // it. If we might have externally-stored decls with this name, look them
2045 // up and perform the insertion. If this decl was declared outside its
2046 // semantic context, buildLookup won't add it, so add it now.
2047 //
2048 // FIXME: As a performance hack, don't add such decls into the translation
2049 // unit unless we're in C++, since qualified lookup into the TU is never
2050 // performed.
2051 if (LookupPtr || hasExternalVisibleStorage() ||
2052 ((!Recoverable || D->getDeclContext() != D->getLexicalDeclContext()) &&
2053 (getParentASTContext().getLangOpts().CPlusPlus ||
2054 !isTranslationUnit()))) {
2055 // If we have lazily omitted any decls, they might have the same name as
2056 // the decl which we are adding, so build a full lookup table before adding
2057 // this decl.
2058 buildLookup();
2059 makeDeclVisibleInContextImpl(D, Internal);
2060 } else {
2061 setHasLazyLocalLexicalLookups(true);
2062 }
2063
2064 // If we are a transparent context or inline namespace, insert into our
2065 // parent context, too. This operation is recursive.
2068 makeDeclVisibleInContextWithFlags(D, Internal, Recoverable);
2069
2070 auto *DCAsDecl = cast<Decl>(this);
2071 // Notify that a decl was made visible unless we are a Tag being defined.
2072 if (!(isa<TagDecl>(DCAsDecl) && cast<TagDecl>(DCAsDecl)->isBeingDefined()))
2073 if (ASTMutationListener *L = DCAsDecl->getASTMutationListener())
2074 L->AddedVisibleDecl(this, D);
2075}
2076
2077void DeclContext::makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal) {
2078 // Find or create the stored declaration map.
2079 StoredDeclsMap *Map = LookupPtr;
2080 if (!Map) {
2082 Map = CreateStoredDeclsMap(*C);
2083 }
2084
2085 // If there is an external AST source, load any declarations it knows about
2086 // with this declaration's name.
2087 // If the lookup table contains an entry about this name it means that we
2088 // have already checked the external source.
2089 if (!Internal)
2090 if (ExternalASTSource *Source = getParentASTContext().getExternalSource())
2092 Map->find(D->getDeclName()) == Map->end())
2093 Source->FindExternalVisibleDeclsByName(this, D->getDeclName());
2094
2095 // Insert this declaration into the map.
2096 StoredDeclsList &DeclNameEntries = (*Map)[D->getDeclName()];
2097
2098 if (Internal) {
2099 // If this is being added as part of loading an external declaration,
2100 // this may not be the only external declaration with this name.
2101 // In this case, we never try to replace an existing declaration; we'll
2102 // handle that when we finalize the list of declarations for this name.
2103 DeclNameEntries.setHasExternalDecls();
2104 DeclNameEntries.prependDeclNoReplace(D);
2105 return;
2106 }
2107
2108 DeclNameEntries.addOrReplaceDecl(D);
2109}
2110
2112 return cast<UsingDirectiveDecl>(*I);
2113}
2114
2115/// Returns iterator range [First, Last) of UsingDirectiveDecls stored within
2116/// this context.
2118 // FIXME: Use something more efficient than normal lookup for using
2119 // directives. In C++, using directives are looked up more than anything else.
2120 lookup_result Result = lookup(UsingDirectiveDecl::getName());
2121 return udir_range(Result.begin(), Result.end());
2122}
2123
2124//===----------------------------------------------------------------------===//
2125// Creation and Destruction of StoredDeclsMaps. //
2126//===----------------------------------------------------------------------===//
2127
2128StoredDeclsMap *DeclContext::CreateStoredDeclsMap(ASTContext &C) const {
2129 assert(!LookupPtr && "context already has a decls map");
2130 assert(getPrimaryContext() == this &&
2131 "creating decls map on non-primary context");
2132
2133 StoredDeclsMap *M;
2135 if (Dependent)
2136 M = new DependentStoredDeclsMap();
2137 else
2138 M = new StoredDeclsMap();
2139 M->Previous = C.LastSDM;
2140 C.LastSDM = llvm::PointerIntPair<StoredDeclsMap*,1>(M, Dependent);
2141 LookupPtr = M;
2142 return M;
2143}
2144
2145void ASTContext::ReleaseDeclContextMaps() {
2146 // It's okay to delete DependentStoredDeclsMaps via a StoredDeclsMap
2147 // pointer because the subclass doesn't add anything that needs to
2148 // be deleted.
2149 StoredDeclsMap::DestroyAll(LastSDM.getPointer(), LastSDM.getInt());
2150 LastSDM.setPointer(nullptr);
2151}
2152
2154 while (Map) {
2155 // Advance the iteration before we invalidate memory.
2156 llvm::PointerIntPair<StoredDeclsMap*,1> Next = Map->Previous;
2157
2158 if (Dependent)
2159 delete static_cast<DependentStoredDeclsMap*>(Map);
2160 else
2161 delete Map;
2162
2163 Map = Next.getPointer();
2164 Dependent = Next.getInt();
2165 }
2166}
2167
2170 const PartialDiagnostic &PDiag) {
2171 assert(Parent->isDependentContext()
2172 && "cannot iterate dependent diagnostics of non-dependent context");
2173 Parent = Parent->getPrimaryContext();
2174 if (!Parent->LookupPtr)
2175 Parent->CreateStoredDeclsMap(C);
2176
2177 auto *Map = static_cast<DependentStoredDeclsMap *>(Parent->LookupPtr);
2178
2179 // Allocate the copy of the PartialDiagnostic via the ASTContext's
2180 // BumpPtrAllocator, rather than the ASTContext itself.
2181 DiagnosticStorage *DiagStorage = nullptr;
2182 if (PDiag.hasStorage())
2183 DiagStorage = new (C) DiagnosticStorage;
2184
2185 auto *DD = new (C) DependentDiagnostic(PDiag, DiagStorage);
2186
2187 // TODO: Maybe we shouldn't reverse the order during insertion.
2188 DD->NextDiagnostic = Map->FirstDiagnostic;
2189 Map->FirstDiagnostic = DD;
2190
2191 return DD;
2192}
2193
2195 return ID & llvm::maskTrailingOnes<DeclID>(32);
2196}
Defines the clang::ASTContext interface.
#define V(N, I)
Definition: ASTContext.h:3323
NodeId Parent
Definition: ASTDiff.cpp:191
This file provides some common utility functions for processing Lambda related AST Constructs.
const Decl * D
Expr * E
static bool shouldBeHidden(NamedDecl *D)
shouldBeHidden - Determine whether a declaration which was declared within its semantic context shoul...
Definition: DeclBase.cpp:1625
static bool isLinkageSpecContext(const DeclContext *DC, LinkageSpecLanguageIDs ID)
Definition: DeclBase.cpp:1350
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:1152
static Decl * getNonClosureContext(T *D)
Starting at a given context (a Decl or DeclContext), look for a code context that is not a closure (a...
Definition: DeclBase.cpp:1199
static AvailabilityResult CheckAvailability(ASTContext &Context, const AvailabilityAttr *A, std::string *Message, VersionTuple EnclosingVersion)
Determine the availability of the given declaration based on the target platform.
Definition: DeclBase.cpp:647
void collectAllContextsImpl(T *Self, SmallVectorImpl< DeclContext * > &Contexts)
Definition: DeclBase.cpp:1479
static StringRef getRealizedPlatform(const AvailabilityAttr *A, const ASTContext &Context)
Definition: DeclBase.cpp:625
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
This file defines OpenMP nodes for declarative directives.
Defines the C++ template declaration subclasses.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
llvm::MachO::Record Record
Definition: MachO.h:31
Defines the clang::Module class, which describes a module in the source code.
Defines types useful for describing an Objective-C runtime.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::SourceLocation class and associated facilities.
static QualType getPointeeType(const MemRegion *R)
C Language Family Type Representation.
std::string Label
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:186
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2809
ASTMutationListener * getASTMutationListener() const
Retrieve a pointer to the AST mutation listener associated with this AST context, if any.
Definition: ASTContext.h:1230
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
Definition: ASTContext.h:2815
const LangOptions & getLangOpts() const
Definition: ASTContext.h:787
llvm::BumpPtrAllocator & getAllocator() const
Definition: ASTContext.h:726
void eraseDeclAttrs(const Decl *D)
Erase the attributes corresponding to the given declaration.
void addedLocalImportDecl(ImportDecl *Import)
Notify the AST context that a new import declaration has been parsed or implicitly created within thi...
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:730
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:769
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
Definition: ASTContext.h:1215
Module * getCurrentNamedModule() const
Get module under construction, nullptr if this is not a C++20 module.
Definition: ASTContext.h:1083
AttrVec & getDeclAttrs(const Decl *D)
Retrieve the attributes for the given declaration.
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Attr - This represents one attribute.
Definition: Attr.h:42
bool isInherited() const
Definition: Attr.h:97
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4506
Pointer to a block type.
Definition: Type.h:3368
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1358
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:2272
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
Definition: DeclBase.h:2335
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1425
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:2055
udir_range using_directives() const
Returns iterator range [First, Last) of UsingDirectiveDecls stored within this context.
Definition: DeclBase.cpp:2117
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
Definition: DeclBase.h:2184
bool isFileContext() const
Definition: DeclBase.h:2126
void setHasExternalVisibleStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations visible in this context.
Definition: DeclBase.h:2648
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:2020
DeclContextLookupResult lookup_result
Definition: DeclBase.h:2519
static std::pair< Decl *, Decl * > BuildDeclChain(ArrayRef< Decl * > Decls, bool FieldsAlreadyLoaded)
Build up a chain of declarations.
Definition: DeclBase.cpp:1500
bool isTransparentContext() const
isTransparentContext - Determines whether this context is a "transparent" context,...
Definition: DeclBase.cpp:1343
Decl * getNonClosureAncestor()
Find the nearest non-closure ancestor of this context, i.e.
Definition: DeclBase.cpp:1222
ASTContext & getParentASTContext() const
Definition: DeclBase.h:2084
bool isExternCXXContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:1375
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1309
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
Definition: DeclBase.cpp:2002
bool isClosure() const
Definition: DeclBase.h:2088
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:2071
bool isNamespace() const
Definition: DeclBase.h:2144
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1829
bool isLookupContext() const
Test whether the context supports looking up names.
Definition: DeclBase.h:2121
const BlockDecl * getInnermostBlockDecl() const
Return this DeclContext if it is a BlockDecl.
Definition: DeclBase.cpp:1276
bool hasExternalVisibleStorage() const
Whether this DeclContext has external storage containing additional declarations that are visible in ...
Definition: DeclBase.h:2642
const char * getDeclKindName() const
Definition: DeclBase.cpp:186
bool isTranslationUnit() const
Definition: DeclBase.h:2131
bool isRecord() const
Definition: DeclBase.h:2135
void collectAllContexts(SmallVectorImpl< DeclContext * > &Contexts)
Collects all of the declaration contexts that are semantically connected to this declaration context.
Definition: DeclBase.cpp:1486
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1965
llvm::iterator_range< udir_iterator > udir_range
Definition: DeclBase.h:2596
Decl * FirstDecl
FirstDecl - The first declaration stored within this declaration context.
Definition: DeclBase.h:2025
DeclContext(Decl::Kind K)
Definition: DeclBase.cpp:1230
void addDeclInternal(Decl *D)
Add the declaration D into this context, but suppress searches for external declarations with the sam...
Definition: DeclBase.cpp:1751
bool containsDeclAndLoad(Decl *D) const
Checks whether a declaration is in this context.
Definition: DeclBase.cpp:1617
void removeDecl(Decl *D)
Removes a declaration from this context.
Definition: DeclBase.cpp:1662
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1743
StoredDeclsMap * buildLookup()
Ensure the lookup structure is fully-built and return it.
Definition: DeclBase.cpp:1766
bool hasValidDeclKind() const
Definition: DeclBase.cpp:177
bool isStdNamespace() const
Definition: DeclBase.cpp:1293
lookup_result noload_lookup(DeclarationName Name)
Find the declarations with the given name that are visible within this context; don't attempt to retr...
Definition: DeclBase.cpp:1894
static bool classof(const Decl *D)
Definition: DeclBase.cpp:1240
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
Definition: DeclBase.cpp:1612
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:2630
void setUseQualifiedLookup(bool use=true) const
Definition: DeclBase.h:2661
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
Definition: DeclBase.cpp:1983
Decl * LastDecl
LastDecl - The last declaration stored within this declaration context.
Definition: DeclBase.h:2031
decl_range noload_decls() const
noload_decls_begin/end - Iterate over the declarations stored in this context that are currently load...
Definition: DeclBase.h:2323
friend class DependentDiagnostic
For CreateStoredDeclsMap.
Definition: DeclBase.h:1434
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1399
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
Definition: DeclBase.cpp:1991
bool decls_empty() const
Definition: DeclBase.cpp:1605
bool isInlineNamespace() const
Definition: DeclBase.cpp:1288
DeclContextBitfields DeclContextBits
Definition: DeclBase.h:1987
bool isFunctionOrMethod() const
Definition: DeclBase.h:2107
void setHasExternalLexicalStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations lexically in this context.
Definition: DeclBase.h:2636
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
Definition: DeclBase.cpp:1260
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:1360
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
Definition: DeclBase.cpp:1364
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1379
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
Definition: DeclBase.cpp:1717
void localUncachedLookup(DeclarationName Name, SmallVectorImpl< NamedDecl * > &Results)
A simplistic name lookup mechanism that performs name lookup into this declaration context without co...
Definition: DeclBase.cpp:1926
Decl::Kind getDeclKind() const
Definition: DeclBase.h:2048
DeclContext * getNonTransparentContext()
Definition: DeclBase.cpp:1390
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1599
unsigned getLocalDeclIndex() const
Definition: DeclBase.cpp:2194
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Definition: DeclBase.h:1040
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
Definition: DeclBase.h:1055
const DeclContext * getParentFunctionOrMethod(bool LexicalParent=false) const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext,...
Definition: DeclBase.cpp:317
bool isInStdNamespace() const
Definition: DeclBase.cpp:425
TemplateDecl * getDescribedTemplate() const
If this is a declaration that describes some template, this method returns that template declaration.
Definition: DeclBase.cpp:261
bool isTemplateDecl() const
returns true if this declaration is a template
Definition: DeclBase.cpp:257
static void add(Kind k)
Definition: DeclBase.cpp:224
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
Definition: DeclBase.h:1205
bool hasAttrs() const
Definition: DeclBase.h:524
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:523
void setOwningModuleID(unsigned ID)
Set the owning module ID.
Definition: DeclBase.cpp:129
void addAttr(Attr *A)
Definition: DeclBase.cpp:1014
void setAttrs(const AttrVec &Attrs)
Definition: DeclBase.h:526
bool hasLocalOwningModuleStorage() const
Definition: DeclBase.cpp:141
bool isFunctionPointerType() const
Definition: DeclBase.cpp:1180
bool isInNamedModule() const
Whether this declaration comes from a named module.
Definition: DeclBase.cpp:1148
virtual ~Decl()
ExternalSourceSymbolAttr * getExternalSourceSymbolAttr() const
Looks on this and related declarations for an applicable external source symbol attribute.
Definition: DeclBase.cpp:589
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
Definition: DeclBase.cpp:843
ModuleOwnershipKind getModuleOwnershipKind() const
Get the kind of module ownership for this declaration.
Definition: DeclBase.h:855
bool isParameterPack() const
Whether this declaration is a parameter pack.
Definition: DeclBase.cpp:242
ASTMutationListener * getASTMutationListener() const
Definition: DeclBase.cpp:533
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl,...
Definition: DeclBase.cpp:537
AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple(), StringRef *RealizedPlatform=nullptr) const
Determine the availability of the given declaration.
Definition: DeclBase.cpp:748
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:154
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:89
static unsigned getIdentifierNamespaceForKind(Kind DK)
Definition: DeclBase.cpp:862
virtual Stmt * getBody() const
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: DeclBase.h:1066
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
Definition: DeclBase.cpp:567
bool isFileContextDecl() const
Definition: DeclBase.cpp:430
static Decl * castFromDeclContext(const DeclContext *)
Definition: DeclBase.cpp:1042
Decl * getNextDeclInContext()
Definition: DeclBase.h:451
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
Definition: DeclBase.cpp:284
bool isInExportDeclContext() const
Whether this declaration was exported in a lexical context.
Definition: DeclBase.cpp:1113
SourceLocation getBodyRBrace() const
getBodyRBrace - Gets the right brace of the body, if a body exists.
Definition: DeclBase.cpp:1068
int64_t getID() const
Definition: DeclBase.cpp:1155
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:577
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl's underlying type to extract a FunctionType when possible.
Definition: DeclBase.cpp:1159
bool isInAnotherModuleUnit() const
Whether this declaration comes from another module unit.
Definition: DeclBase.cpp:1122
llvm::PointerIntPair< Decl *, 3, ModuleOwnershipKind > NextInContextAndBits
The next declaration within the same lexical DeclContext.
Definition: DeclBase.h:249
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
Definition: DeclBase.h:825
unsigned getTemplateDepth() const
Determine the number of levels of template parameter surrounding this declaration.
Definition: DeclBase.cpp:296
bool isFromExplicitGlobalModule() const
Whether this declaration comes from explicit global module.
Definition: DeclBase.cpp:1144
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:249
bool canBeWeakImported(bool &IsDefinition) const
Determines whether this symbol can be weak-imported, e.g., whether it would be well-formed to add the...
Definition: DeclBase.cpp:814
void dropAttrs()
Definition: DeclBase.cpp:1007
static DeclContext * castToDeclContext(const Decl *)
Definition: DeclBase.cpp:1055
const TemplateParameterList * getDescribedTemplateParams() const
If this is a declaration that describes some template or partial specialization, this returns the cor...
Definition: DeclBase.cpp:274
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:776
bool isInLocalScopeForInstantiation() const
Determine whether a substitution into this declaration would occur as part of a substitution into a d...
Definition: DeclBase.cpp:398
const Attr * getDefiningAttr() const
Return this declaration's defining attribute if it has one.
Definition: DeclBase.cpp:615
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition: DeclBase.h:2732
DeclContext * getNonTransparentDeclContext()
Return the non transparent context.
Definition: DeclBase.cpp:1192
Decl * getNonClosureContext()
Find the innermost non-closure ancestor of this declaration, walking up through blocks,...
Definition: DeclBase.cpp:1218
bool isInvalidDecl() const
Definition: DeclBase.h:594
unsigned getIdentifierNamespace() const
Definition: DeclBase.h:868
bool hasDefiningAttr() const
Return true if this declaration has an attribute which acts as definition of the entity,...
Definition: DeclBase.cpp:610
bool isLocalExternDecl() const
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:1148
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:508
SourceLocation getLocation() const
Definition: DeclBase.h:445
const char * getDeclKindName() const
Definition: DeclBase.cpp:145
@ IDNS_Ordinary
Ordinary names.
Definition: DeclBase.h:144
@ IDNS_Type
Types, declared with 'struct foo', typedefs, etc.
Definition: DeclBase.h:130
@ IDNS_OMPReduction
This declaration is an OpenMP user defined reduction construction.
Definition: DeclBase.h:178
@ IDNS_Label
Labels, declared with 'x:' and referenced with 'goto x'.
Definition: DeclBase.h:117
@ IDNS_Member
Members, declared with object declarations within tag definitions.
Definition: DeclBase.h:136
@ IDNS_OMPMapper
This declaration is an OpenMP user defined mapper.
Definition: DeclBase.h:181
@ IDNS_ObjCProtocol
Objective C @protocol.
Definition: DeclBase.h:147
@ IDNS_Namespace
Namespaces, declared with 'namespace foo {}'.
Definition: DeclBase.h:140
@ IDNS_Using
This declaration is a using declaration.
Definition: DeclBase.h:163
@ IDNS_Tag
Tags, declared with 'struct foo;' and referenced with 'struct foo'.
Definition: DeclBase.h:125
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
Definition: DeclBase.cpp:232
void setLocalOwningModule(Module *M)
Definition: DeclBase.h:812
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: DeclBase.h:1028
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
Definition: DeclBase.h:614
unsigned Access
Access - Used by C++ decls for the access specifier.
Definition: DeclBase.h:339
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
Definition: DeclBase.cpp:552
DeclContext * getDeclContext()
Definition: DeclBase.h:454
attr_range attrs() const
Definition: DeclBase.h:541
bool isInAnonymousNamespace() const
Definition: DeclBase.cpp:415
static void EnableStatistics()
Definition: DeclBase.cpp:196
TranslationUnitDecl * getTranslationUnitDecl()
Definition: DeclBase.cpp:508
VersionTuple getVersionIntroduced() const
Retrieve the version of the target platform in which this declaration was introduced.
Definition: DeclBase.cpp:800
bool hasOwningModule() const
Is this declaration owned by some module?
Definition: DeclBase.h:820
static void PrintStats()
Definition: DeclBase.cpp:200
void updateOutOfDate(IdentifierInfo &II) const
Update a potentially out-of-date declaration.
Definition: DeclBase.cpp:63
AttrVec & getAttrs()
Definition: DeclBase.h:530
static bool isFlexibleArrayMemberLike(ASTContext &Context, const Decl *D, QualType Ty, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution)
Whether it resembles a flexible array member.
Definition: DeclBase.cpp:435
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
Definition: DeclBase.cpp:358
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Definition: DeclBase.h:897
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:362
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:957
@ VisibleWhenImported
This declaration has an owning module, and is visible when that module is imported.
Kind getKind() const
Definition: DeclBase.h:448
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
Definition: DeclBase.h:860
const LangOptions & getLangOpts() const LLVM_READONLY
Helper to get the language options from the ASTContext.
Definition: DeclBase.cpp:529
GlobalDeclID getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
Definition: DeclBase.cpp:113
unsigned getOwningModuleID() const
Retrieve the global ID of the module that owns this particular declaration.
Definition: DeclBase.cpp:121
The name of a declaration.
A dependently-generated diagnostic.
static DependentDiagnostic * Create(ASTContext &Context, DeclContext *Parent, AccessNonce _, SourceLocation Loc, bool IsMemberAccess, AccessSpecifier AS, NamedDecl *TargetDecl, CXXRecordDecl *NamingClass, QualType BaseObjectType, const PartialDiagnostic &PDiag)
This represents one expression.
Definition: Expr.h:110
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:277
RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing.
Abstract interface for external sources of AST nodes.
static DeclContextLookupResult SetExternalVisibleDeclsForName(const DeclContext *DC, DeclarationName Name, ArrayRef< NamedDecl * > Decls)
Definition: DeclBase.cpp:1584
static DeclContextLookupResult SetNoExternalVisibleDeclsForName(const DeclContext *DC, DeclarationName Name)
Definition: DeclBase.cpp:1569
virtual Module * getModule(unsigned ID)
Retrieve the module that corresponds to the given module ID.
virtual bool FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name)
Find all declarations with the given name in the given context, and add them to the context by callin...
virtual void updateOutOfDateIdentifier(const IdentifierInfo &II)
Update an out-of-date identifier.
virtual void FindExternalLexicalDecls(const DeclContext *DC, llvm::function_ref< bool(Decl::Kind)> IsKindWeWant, SmallVectorImpl< Decl * > &Result)
Finds all declarations lexically contained within the given DeclContext, after applying an optional f...
Represents a member of a struct/union/class.
Definition: Decl.h:3069
Represents a function declaration or definition.
Definition: Decl.h:1971
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:4275
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StringRef getName() const
Return the actual identifier string.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:461
bool trackLocalOwningModule() const
Do we need to track the owning module for a local declaration?
Definition: LangOptions.h:616
Represents a linkage specification.
Definition: DeclCXX.h:2934
Describes a module or submodule.
Definition: Module.h:105
bool isExplicitGlobalModule() const
Definition: Module.h:203
bool isNamedModule() const
Does this Module is a named module of a standard named module?
Definition: Module.h:185
This represents a decl that may have a name.
Definition: Decl.h:249
Represent a C++ namespace.
Definition: Decl.h:547
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:28
bool hasWeakClassImport() const
Does this runtime support weakly importing classes?
Definition: ObjCRuntime.h:378
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:3158
void print(raw_ostream &OS) const override
Definition: DeclBase.cpp:331
A (possibly-)qualified type.
Definition: Type.h:942
QualType getCanonicalType() const
Definition: Type.h:7796
Represents a struct/union/class.
Definition: Decl.h:4180
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:3399
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
void print(raw_ostream &OS, const SourceManager &SM) const
Stmt - This represents one statement.
Definition: Stmt.h:84
An array of decls optimized for the common case of only containing one entry.
void addOrReplaceDecl(NamedDecl *D)
If this is a redeclaration of an existing decl, replace the old one with D.
void prependDeclNoReplace(NamedDecl *D)
Add a declaration to the list without checking if it replaces anything.
static void DestroyAll(StoredDeclsMap *Map, bool Dependent)
Definition: DeclBase.cpp:2153
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3596
bool isBeingDefined() const
Return true if this decl is currently being defined.
Definition: Decl.h:3719
TagDecl * getDefinition() const
Returns the TagDecl that actually defines this struct/union/class/enum.
Definition: Decl.cpp:4748
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1256
StringRef getPlatformName() const
Retrieve the name of the platform as it is used in the availability attribute.
Definition: TargetInfo.h:1659
VersionTuple getPlatformMinVersion() const
Retrieve the minimum desired version of the platform, to which the program should be compiled.
Definition: TargetInfo.h:1663
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:394
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:73
The top declaration context.
Definition: Decl.h:84
ASTContext & getASTContext() const
Definition: Decl.h:120
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:59
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:89
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:2684
A container of type source information.
Definition: Type.h:7715
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:256
bool isBlockPointerType() const
Definition: Type.h:8007
bool isFunctionReferenceType() const
Definition: Type.h:8040
bool isFunctionPointerType() const
Definition: Type.h:8033
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:8584
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:8517
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3444
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:3494
Wrapper for source info for typedefs.
Definition: TypeLoc.h:693
Represents C++ using-directive.
Definition: DeclCXX.h:3015
specific_attr_iterator - Iterates over a subrange of an AttrVec, only providing attributes that are o...
Definition: AttrIterator.h:33
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
The JSON file list parser is used to communicate input to InstallAPI.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ CPlusPlus
Definition: LangStandard.h:56
SmallVector< Attr *, 4 > AttrVec
AttrVec - A vector of Attr, which is how they are stored on the AST.
Definition: AttrIterator.h:28
LinkageSpecLanguageIDs
Represents the language in a linkage specification.
Definition: DeclCXX.h:2926
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition: ASTLambda.h:27
@ Result
The result type of a method or function.
AvailabilityResult
Captures the result of checking the availability of a declaration.
Definition: DeclBase.h:72
@ AR_NotYetIntroduced
Definition: DeclBase.h:74
@ AR_Available
Definition: DeclBase.h:73
@ AR_Deprecated
Definition: DeclBase.h:75
@ AR_Unavailable
Definition: DeclBase.h:76
const FunctionProtoType * T
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ AS_public
Definition: Specifiers.h:121
@ AS_none
Definition: Specifiers.h:124
UsingDirectiveDecl * operator*() const
Definition: DeclBase.cpp:2111