13 #ifndef LLVM_CLANG_AST_DECL_H
14 #define LLVM_CLANG_AST_DECL_H
36 #include "llvm/ADT/APSInt.h"
37 #include "llvm/ADT/ArrayRef.h"
38 #include "llvm/ADT/PointerIntPair.h"
39 #include "llvm/ADT/PointerUnion.h"
40 #include "llvm/ADT/StringRef.h"
41 #include "llvm/ADT/iterator_range.h"
42 #include "llvm/Support/Casting.h"
43 #include "llvm/Support/Compiler.h"
44 #include "llvm/Support/TrailingObjects.h"
55 struct ASTTemplateArgumentListInfo;
57 class DependentFunctionTemplateSpecializationInfo;
60 class FunctionTemplateDecl;
61 class FunctionTemplateSpecializationInfo;
62 class FunctionTypeLoc;
64 class MemberSpecializationInfo;
72 class TemplateArgumentList;
73 class TemplateArgumentListInfo;
74 class TemplateParameterList;
75 class TypeAliasTemplateDecl;
76 class UnresolvedSetImpl;
77 class VarTemplateDecl;
105 virtual void anchor();
140 private llvm::TrailingObjects<PragmaCommentDecl, char> {
143 friend TrailingObjects;
149 :
Decl(PragmaComment, TU, CommentLoc), CommentKind(CommentKind) {}
151 virtual void anchor();
163 StringRef
getArg()
const {
return getTrailingObjects<char>(); }
174 private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {
177 friend TrailingObjects;
183 :
Decl(PragmaDetectMismatch, TU, Loc), ValueStart(ValueStart) {}
185 virtual void anchor();
195 StringRef
getName()
const {
return getTrailingObjects<char>(); }
196 StringRef
getValue()
const {
return getTrailingObjects<char>() + ValueStart; }
225 virtual void anchor();
253 virtual void anchor();
256 NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY;
260 :
Decl(DK, DC, L), Name(N) {}
275 assert(Name.isIdentifier() &&
"Name is not a simple identifier");
348 bool Qualified)
const;
375 if (isa<EnumDecl>(DC))
440 std::optional<Visibility>
461 if (this->
getKind() != UsingShadow &&
462 this->
getKind() != ConstructorUsingShadow &&
463 this->
getKind() != ObjCCompatibleAlias &&
464 this->
getKind() != NamespaceAlias)
467 return getUnderlyingDeclImpl();
499 bool MSAsmNameResolved =
false;
508 :
NamedDecl(
Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}
510 void anchor()
override;
546 enum Flags :
unsigned { F_Inline = 1 << 0, F_Nested = 1 << 1 };
559 llvm::PointerIntPair<NamespaceDecl *, 2, unsigned>
560 AnonOrFirstNamespaceAndFlags;
608 return AnonOrFirstNamespaceAndFlags.getInt() & F_Inline;
613 unsigned F = AnonOrFirstNamespaceAndFlags.getInt();
615 AnonOrFirstNamespaceAndFlags.setInt(F | F_Inline);
617 AnonOrFirstNamespaceAndFlags.setInt(F & ~F_Inline);
625 return AnonOrFirstNamespaceAndFlags.getInt() & F_Nested;
630 unsigned F = AnonOrFirstNamespaceAndFlags.getInt();
632 AnonOrFirstNamespaceAndFlags.setInt(F | F_Nested);
634 AnonOrFirstNamespaceAndFlags.setInt(F & ~F_Nested);
706 void anchor()
override;
711 :
NamedDecl(DK, DC, L, N), DeclType(T) {}
773 Expr *TrailingRequiresClause =
nullptr;
776 llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;
782 bool hasExtInfo()
const {
return DeclInfo.is<ExtInfo*>(); }
783 ExtInfo *getExtInfo() {
return DeclInfo.get<ExtInfo*>(); }
784 const ExtInfo *getExtInfo()
const {
return DeclInfo.get<ExtInfo*>(); }
790 :
ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {}
798 ? getExtInfo()->TInfo
804 getExtInfo()->TInfo = TI;
826 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
834 return hasExtInfo() ? getExtInfo()->QualifierLoc
844 return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
849 return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
856 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
861 return getExtInfo()->TemplParamLists[index];
873 return K >= firstDeclarator && K <= lastDeclarator;
957 using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;
968 class VarDeclBitfields {
973 unsigned TSCSpec : 2;
974 unsigned InitStyle : 2;
978 unsigned ARCPseudoStrong : 1;
980 enum { NumVarDeclBits = 8 };
1002 unsigned HasInheritedDefaultArg : 1;
1011 unsigned IsKNRPromoted : 1;
1014 unsigned IsObjCMethodParam : 1;
1037 unsigned IsThisDeclarationADemotedDefinition : 1;
1041 unsigned ExceptionVar : 1;
1046 unsigned NRVOVariable : 1;
1050 unsigned CXXForRangeDecl : 1;
1053 unsigned ObjCForDecl : 1;
1056 unsigned IsInline : 1;
1059 unsigned IsInlineSpecified : 1;
1062 unsigned IsConstexpr : 1;
1066 unsigned IsInitCapture : 1;
1071 unsigned PreviousDeclInSameBlockScope : 1;
1075 unsigned ImplicitParamKind : 3;
1077 unsigned EscapingByref : 1;
1134 assert(
VarDeclBits.TSCSpec == TSC &&
"truncation");
1216 return DC->getRedeclContext()->isFunctionOrMethod();
1303 if (K == ParmVar || K == ImplicitParam)
1369 bool IsConstantInitialization)
const;
1429 return isa<ParmVarDecl>(
this) ?
false :
1440 assert(!isa<ParmVarDecl>(
this) &&
"Cannot demote ParmVarDecls!");
1450 assert(!isa<ParmVarDecl>(
this));
1468 assert(!isa<ParmVarDecl>(
this));
1478 assert(!isa<ParmVarDecl>(
this));
1507 return isa<ParmVarDecl>(
this) ?
false
1511 assert(!isa<ParmVarDecl>(
this));
1516 assert(!isa<ParmVarDecl>(
this));
1525 assert(!isa<ParmVarDecl>(
this));
1534 assert(!isa<ParmVarDecl>(
this));
1545 return isa<ParmVarDecl>(
this)
1550 assert(!isa<ParmVarDecl>(
this));
1658 void anchor()
override;
1733 :
VarDecl(DK, C, DC, StartLoc, IdLoc,
Id, T, TInfo, S) {
1754 setParameterIndex(parameterIndex);
1764 setParameterIndex(parameterIndex);
1785 return getParameterIndex();
1880 void setParameterIndex(
unsigned parameterIndex) {
1881 if (parameterIndex >= ParameterIndexSentinel) {
1882 setParameterIndexLarge(parameterIndex);
1887 assert(
ParmVarDeclBits.ParameterIndex == parameterIndex &&
"truncation!");
1889 unsigned getParameterIndex()
const {
1891 return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
1894 void setParameterIndexLarge(
unsigned parameterIndex);
1895 unsigned getParameterIndexLarge()
const;
1947 : llvm::TrailingObjects<DefaultedFunctionInfo, DeclAccessPair> {
1948 friend TrailingObjects;
1949 unsigned NumLookups;
1957 return {getTrailingObjects<DeclAccessPair>(), NumLookups};
2006 TemplateOrSpecialization;
2033 void setFunctionTemplateSpecialization(
ASTContext &C,
2061 const DeclarationNameInfo &NameInfo, QualType T,
2064 Expr *TrailingRequiresClause =
nullptr);
2100 Expr *TrailingRequiresClause =
nullptr) {
2105 TrailingRequiresClause);
2113 Expr *TrailingRequiresClause);
2129 if (FPT && FPT->isVariadic())
2178 bool CheckForPendingFriendDefinition =
false)
const;
2301 "Can't set default loc is function isn't explicitly defaulted");
2302 DefaultKWLoc = NewLoc;
2308 auto *DeclAsWritten =
this;
2310 DeclAsWritten = Pattern;
2311 return !(DeclAsWritten->isDeleted() ||
2312 DeclAsWritten->getCanonicalDecl()->isDefaulted());
2477 std::optional<unsigned> *AlignmentParam =
nullptr,
2478 bool *IsNothrow =
nullptr)
const;
2581 unsigned getBuiltinID(
bool ConsiderWrapperFunctions =
false)
const;
2609 return ParamInfo[i];
2613 return ParamInfo[i];
2875 setFunctionTemplateSpecialization(
getASTContext(), Template, TemplateArgs,
2876 InsertPos, TSK, TemplateArgsAsWritten,
2877 PointOfInstantiation);
2932 return K >= firstFunction && K <= lastFunction;
2944 unsigned BitField : 1;
2945 unsigned Mutable : 1;
2946 mutable unsigned CachedFieldIndex : 30;
2952 enum InitStorageKind {
2968 ISK_CapturedVLAType,
2973 struct InitAndBitWidth {
2987 llvm::PointerIntPair<void *, 2, InitStorageKind> InitStorage;
2995 BitField(
false), Mutable(Mutable), CachedFieldIndex(0),
2996 InitStorage(nullptr, (InitStorageKind) InitStyle) {
3035 void *Ptr = InitStorage.getPointer();
3037 return static_cast<InitAndBitWidth*
>(Ptr)->BitWidth;
3038 return static_cast<Expr*
>(Ptr);
3047 "bit width or captured type already set");
3048 assert(Width &&
"no bit width specified");
3049 InitStorage.setPointer(
3050 InitStorage.getInt()
3053 :
static_cast<void*
>(Width));
3060 assert(
isBitField() &&
"no bitfield width to remove");
3077 InitStorageKind storageKind = InitStorage.getInt();
3078 return (storageKind == ISK_CapturedVLAType
3093 void *Ptr = InitStorage.getPointer();
3095 return static_cast<InitAndBitWidth*
>(Ptr)->Init;
3096 return static_cast<Expr*
>(Ptr);
3103 static_cast<InitAndBitWidth*
>(InitStorage.getPointer())->Init = Init;
3105 InitStorage.setPointer(Init);
3111 InitStorage.setPointerAndInt(
getBitWidth(), ISK_NoInit);
3117 return InitStorage.getInt() == ISK_CapturedVLAType;
3123 InitStorage.getPointer())
3200 unsigned ChainingSize;
3206 void anchor()
override;
3228 assert(
chain().size() >= 2);
3229 return cast<FieldDecl>(
chain().back());
3233 assert(
chain().size() >= 2);
3234 return dyn_cast<VarDecl>(
chain().front());
3253 mutable const Type *TypeForDecl =
nullptr;
3258 void anchor()
override;
3289 struct alignas(8) ModedTInfo {
3296 mutable llvm::PointerIntPair<
3297 llvm::PointerUnion<TypeSourceInfo *, ModedTInfo *>, 2>
3300 void anchor()
override;
3307 MaybeModedTInfo(TInfo, 0) {}
3335 return MaybeModedTInfo.getPointer().is<ModedTInfo *>();
3339 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->first
3344 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->second
3345 : MaybeModedTInfo.getPointer()
3351 MaybeModedTInfo.setPointer(newType);
3356 ModedTInfo({unmodedTSI, modedTy}));
3373 if (MaybeModedTInfo.getInt())
3374 return MaybeModedTInfo.getInt() & 0x2;
3375 return isTransparentTagSlow();
3381 return K >= firstTypedefName && K <= lastTypedefName;
3385 bool isTransparentTagSlow()
const;
3417 Template(
nullptr) {}
3460 llvm::PointerUnion<TypedefNameDecl *, ExtInfo *> TypedefNameDeclOrQualifier;
3462 bool hasExtInfo()
const {
return TypedefNameDeclOrQualifier.is<
ExtInfo *>(); }
3463 ExtInfo *getExtInfo() {
return TypedefNameDeclOrQualifier.get<ExtInfo *>(); }
3464 const ExtInfo *getExtInfo()
const {
3465 return TypedefNameDeclOrQualifier.get<ExtInfo *>();
3470 SourceLocation L, IdentifierInfo *
Id,
TagDecl *PrevDecl,
3471 SourceLocation StartL);
3572 TagDeclBits.IsEmbeddedInDeclarator = isInDeclarator;
3600 return TagDeclBits.IsThisDeclarationADemotedDefinition;
3607 "Should demote definitions only, not forward declarations");
3609 TagDeclBits.IsThisDeclarationADemotedDefinition =
true;
3665 return hasExtInfo() ? nullptr
3736 llvm::PointerUnion<const Type *, TypeSourceInfo *> IntegerType;
3756 bool Scoped,
bool ScopedUsingClassTag,
bool Fixed);
3758 void anchor()
override;
3765 void setNumPositiveBits(
unsigned Num) {
3767 assert(
EnumDeclBits.NumPositiveBits == Num &&
"can't store this bitcount");
3772 void setNumNegativeBits(
unsigned Num) {
EnumDeclBits.NumNegativeBits = Num; }
3793 bool hasODRHash()
const {
return EnumDeclBits.HasODRHash; }
3794 void setHasODRHash(
bool Hash =
true) {
EnumDeclBits.HasODRHash = Hash; }
3807 return cast_or_null<EnumDecl>(
3828 bool IsScoped,
bool IsScopedUsingClassTag,
3843 unsigned NumPositiveBits,
3844 unsigned NumNegativeBits);
3881 if (
const Type *T = IntegerType.dyn_cast<
const Type*>())
3883 return IntegerType.get<
TypeSourceInfo*>()->getType().getUnqualifiedType();
3978 return SpecializationInfo;
4037 return cast_or_null<RecordDecl>(
4121 return RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion;
4221 using field_range = llvm::iterator_range<specific_decl_iterator<FieldDecl>>;
4240 return K >= firstRecord && K <= lastRecord;
4262 void LoadFieldsFromExternalStorage()
const;
4266 void setODRHash(
unsigned Hash) {
RecordDeclBits.ODRHash = Hash; }
4275 :
Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}
4277 virtual void anchor();
4310 Stmt *Statement =
nullptr;
4313 :
Decl(TopLevelStmt, DC, L), Statement(S) {}
4315 virtual void anchor();
4345 llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;
4354 : VariableAndFlags(variable,
4355 (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
4363 bool isByRef()
const {
return VariableAndFlags.getInt() & flag_isByRef; }
4375 bool isNested()
const {
return VariableAndFlags.getInt() & flag_isNested; }
4387 unsigned NumParams = 0;
4389 Stmt *Body =
nullptr;
4392 const Capture *Captures =
nullptr;
4393 unsigned NumCaptures = 0;
4395 unsigned ManglingNumber = 0;
4396 Decl *ManglingContextDecl =
nullptr;
4440 return ParamInfo[i];
4444 return ParamInfo[i];
4496 bool CapturesCXXThis);
4503 ManglingNumber = Number;
4504 ManglingContextDecl = Ctx;
4524 private llvm::TrailingObjects<CapturedDecl, ImplicitParamDecl *> {
4535 unsigned ContextParam;
4538 llvm::PointerIntPair<Stmt *, 1, bool> BodyAndNothrow;
4543 return getTrailingObjects<ImplicitParamDecl *>();
4546 ImplicitParamDecl **getParams() {
4547 return getTrailingObjects<ImplicitParamDecl *>();
4556 unsigned NumParams);
4558 unsigned NumParams);
4569 assert(i < NumParams);
4570 return getParams()[i];
4573 assert(i < NumParams);
4587 assert(ContextParam < NumParams);
4591 assert(i < NumParams);
4637 llvm::TrailingObjects<ImportDecl, SourceLocation> {
4641 friend TrailingObjects;
4644 Module *ImportedModule =
nullptr;
4654 llvm::PointerIntPair<ImportDecl *, 1, bool> NextLocalImportAndComplete;
4664 bool isImportComplete()
const {
return NextLocalImportAndComplete.getInt(); }
4666 void setImportComplete(
bool C) { NextLocalImportAndComplete.setInt(
C); }
4670 ImportDecl *getNextLocalImport()
const {
4671 return NextLocalImportAndComplete.getPointer();
4674 void setNextLocalImport(ImportDecl *Import) {
4675 NextLocalImportAndComplete.setPointer(Import);
4681 SourceLocation StartLoc, Module *Imported,
4682 ArrayRef<SourceLocation> IdentifierLocs);
4687 SourceLocation StartLoc, Module *Imported,
4688 SourceLocation EndLoc);
4692 unsigned NumLocations);
4717 virtual void anchor();
4766 virtual void anchor();