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"
55struct ASTTemplateArgumentListInfo;
57class DependentFunctionTemplateSpecializationInfo;
60class FunctionTemplateDecl;
61class FunctionTemplateSpecializationInfo;
64class MemberSpecializationInfo;
72class TemplateArgumentList;
73class TemplateArgumentListInfo;
74class TemplateParameterList;
75class TypeAliasTemplateDecl;
76class UnresolvedSetImpl;
106 virtual void anchor();
141 private llvm::TrailingObjects<PragmaCommentDecl, char> {
144 friend TrailingObjects;
150 :
Decl(PragmaComment, TU, CommentLoc), CommentKind(CommentKind) {}
152 virtual void anchor();
164 StringRef
getArg()
const {
return getTrailingObjects<char>(); }
175 private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {
178 friend TrailingObjects;
184 :
Decl(PragmaDetectMismatch, TU, Loc), ValueStart(ValueStart) {}
186 virtual void anchor();
196 StringRef
getName()
const {
return getTrailingObjects<char>(); }
197 StringRef
getValue()
const {
return getTrailingObjects<char>() + ValueStart; }
226 virtual void anchor();
254 virtual void anchor();
257 NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY;
261 :
Decl(DK, DC, L), Name(N) {}
276 assert(Name.isIdentifier() &&
"Name is not a simple identifier");
376 if (isa<EnumDecl>(DC))
439 std::optional<Visibility>
462 if (this->
getKind() != UsingShadow &&
463 this->
getKind() != ConstructorUsingShadow &&
464 this->
getKind() != ObjCCompatibleAlias &&
465 this->
getKind() != NamespaceAlias)
468 return getUnderlyingDeclImpl();
500 bool MSAsmNameResolved =
false;
509 :
NamedDecl(
Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}
511 void anchor()
override;
547 enum Flags :
unsigned { F_Inline = 1 << 0, F_Nested = 1 << 1 };
560 llvm::PointerIntPair<NamespaceDecl *, 2, unsigned>
561 AnonOrFirstNamespaceAndFlags;
609 return AnonOrFirstNamespaceAndFlags.getInt() & F_Inline;
614 unsigned F = AnonOrFirstNamespaceAndFlags.getInt();
616 AnonOrFirstNamespaceAndFlags.setInt(F | F_Inline);
618 AnonOrFirstNamespaceAndFlags.setInt(F & ~F_Inline);
626 return AnonOrFirstNamespaceAndFlags.getInt() & F_Nested;
631 unsigned F = AnonOrFirstNamespaceAndFlags.getInt();
633 AnonOrFirstNamespaceAndFlags.setInt(F | F_Nested);
635 AnonOrFirstNamespaceAndFlags.setInt(F & ~F_Nested);
646 return std::distance(
X.begin(),
X.end()) ==
647 std::distance(Y.begin(), Y.end());
707 void anchor()
override;
712 :
NamedDecl(DK, DC, L, N), DeclType(T) {}
774 Expr *TrailingRequiresClause =
nullptr;
777 llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;
783 bool hasExtInfo()
const {
return DeclInfo.is<ExtInfo*>(); }
784 ExtInfo *getExtInfo() {
return DeclInfo.get<ExtInfo*>(); }
785 const ExtInfo *getExtInfo()
const {
return DeclInfo.get<ExtInfo*>(); }
791 :
ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {}
799 ? getExtInfo()->TInfo
805 getExtInfo()->TInfo = TI;
827 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
835 return hasExtInfo() ? getExtInfo()->QualifierLoc
845 return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
850 return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
857 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
862 return getExtInfo()->TemplParamLists[index];
874 return K >= firstDeclarator && K <= lastDeclarator;
958 using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;
969 class VarDeclBitfields {
976 unsigned TSCSpec : 2;
978 unsigned InitStyle : 2;
982 LLVM_PREFERRED_TYPE(
bool)
983 unsigned ARCPseudoStrong : 1;
985 enum { NumVarDeclBits = 8 };
1003 LLVM_PREFERRED_TYPE(VarDeclBitfields)
1008 LLVM_PREFERRED_TYPE(
bool)
1009 unsigned HasInheritedDefaultArg : 1;
1019 LLVM_PREFERRED_TYPE(
bool)
1020 unsigned IsKNRPromoted : 1;
1023 LLVM_PREFERRED_TYPE(
bool)
1024 unsigned IsObjCMethodParam : 1;
1042 LLVM_PREFERRED_TYPE(VarDeclBitfields)
1048 LLVM_PREFERRED_TYPE(
bool)
1049 unsigned IsThisDeclarationADemotedDefinition : 1;
1053 LLVM_PREFERRED_TYPE(
bool)
1054 unsigned ExceptionVar : 1;
1059 LLVM_PREFERRED_TYPE(
bool)
1060 unsigned NRVOVariable : 1;
1064 LLVM_PREFERRED_TYPE(
bool)
1065 unsigned CXXForRangeDecl : 1;
1068 LLVM_PREFERRED_TYPE(
bool)
1069 unsigned ObjCForDecl : 1;
1072 LLVM_PREFERRED_TYPE(
bool)
1073 unsigned IsInline : 1;
1076 LLVM_PREFERRED_TYPE(
bool)
1077 unsigned IsInlineSpecified : 1;
1080 LLVM_PREFERRED_TYPE(
bool)
1081 unsigned IsConstexpr : 1;
1085 LLVM_PREFERRED_TYPE(
bool)
1086 unsigned IsInitCapture : 1;
1091 LLVM_PREFERRED_TYPE(
bool)
1092 unsigned PreviousDeclInSameBlockScope : 1;
1099 LLVM_PREFERRED_TYPE(
bool)
1100 unsigned EscapingByref : 1;
1157 assert(
VarDeclBits.TSCSpec == TSC &&
"truncation");
1239 return DC->getRedeclContext()->isFunctionOrMethod();
1326 if (K == ParmVar || K == ImplicitParam)
1392 bool IsConstantInitialization)
const;
1452 return isa<ParmVarDecl>(
this) ?
false :
1463 assert(!isa<ParmVarDecl>(
this) &&
"Cannot demote ParmVarDecls!");
1473 assert(!isa<ParmVarDecl>(
this));
1491 assert(!isa<ParmVarDecl>(
this));
1501 assert(!isa<ParmVarDecl>(
this));
1530 return isa<ParmVarDecl>(
this) ?
false
1534 assert(!isa<ParmVarDecl>(
this));
1539 assert(!isa<ParmVarDecl>(
this));
1548 assert(!isa<ParmVarDecl>(
this));
1557 assert(!isa<ParmVarDecl>(
this));
1568 return isa<ParmVarDecl>(
this)
1573 assert(!isa<ParmVarDecl>(
this));
1707 void anchor()
override;
1756 :
VarDecl(DK,
C, DC, StartLoc, IdLoc,
Id, T, TInfo, S) {
1777 setParameterIndex(parameterIndex);
1787 setParameterIndex(parameterIndex);
1808 return getParameterIndex();
1836 return ExplicitObjectParameterIntroducerLoc.
isValid();
1840 ExplicitObjectParameterIntroducerLoc = Loc;
1844 return ExplicitObjectParameterIntroducerLoc;
1918 void setParameterIndex(
unsigned parameterIndex) {
1919 if (parameterIndex >= ParameterIndexSentinel) {
1920 setParameterIndexLarge(parameterIndex);
1925 assert(
ParmVarDeclBits.ParameterIndex == parameterIndex &&
"truncation!");
1927 unsigned getParameterIndex()
const {
1929 return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
1932 void setParameterIndexLarge(
unsigned parameterIndex);
1933 unsigned getParameterIndexLarge()
const;
1985 : llvm::TrailingObjects<DefaultedFunctionInfo, DeclAccessPair> {
1986 friend TrailingObjects;
1987 unsigned NumLookups;
1995 return {getTrailingObjects<DeclAccessPair>(), NumLookups};
2044 TemplateOrSpecialization;
2071 void setFunctionTemplateSpecialization(
ASTContext &
C,
2099 const DeclarationNameInfo &NameInfo, QualType T,
2102 Expr *TrailingRequiresClause =
nullptr);
2138 Expr *TrailingRequiresClause =
nullptr) {
2143 TrailingRequiresClause);
2151 Expr *TrailingRequiresClause);
2167 if (FPT && FPT->isVariadic())
2216 bool CheckForPendingFriendDefinition =
false)
const;
2339 "Can't set default loc is function isn't explicitly defaulted");
2340 DefaultKWLoc = NewLoc;
2346 auto *DeclAsWritten =
this;
2348 DeclAsWritten = Pattern;
2349 return !(DeclAsWritten->isDeleted() ||
2350 DeclAsWritten->getCanonicalDecl()->isDefaulted());
2530 std::optional<unsigned> *AlignmentParam =
nullptr,
2531 bool *IsNothrow =
nullptr)
const;
2638 unsigned getBuiltinID(
bool ConsiderWrapperFunctions =
false)
const;
2666 return ParamInfo[i];
2670 return ParamInfo[i];
2947 setFunctionTemplateSpecialization(
getASTContext(), Template, TemplateArgs,
2948 InsertPos, TSK, TemplateArgsAsWritten,
2949 PointOfInstantiation);
3004 return K >= firstFunction && K <= lastFunction;
3020 enum InitStorageKind {
3036 ISK_CapturedVLAType,
3039 LLVM_PREFERRED_TYPE(
bool)
3040 unsigned BitField : 1;
3041 LLVM_PREFERRED_TYPE(
bool)
3042 unsigned Mutable : 1;
3043 LLVM_PREFERRED_TYPE(InitStorageKind)
3044 unsigned StorageKind : 2;
3045 mutable unsigned CachedFieldIndex : 28;
3049 struct InitAndBitWidthStorage {
3080 Mutable(Mutable), StorageKind((InitStorageKind)InitStyle),
3081 CachedFieldIndex(0),
Init() {
3133 "bit width or captured type already set");
3134 assert(Width &&
"no bit width specified");
3146 assert(
isBitField() &&
"no bitfield width to remove");
3150 Init = ExistingInit;
3171 return (StorageKind == ISK_CapturedVLAType ?
ICIS_NoInit
3201 StorageKind = ISK_NoInit;
3212 return StorageKind == ISK_CapturedVLAType;
3260 const llvm::APSInt &
V)
3269 const llvm::APSInt &
V);
3295 unsigned ChainingSize;
3301 void anchor()
override;
3323 assert(
chain().size() >= 2);
3324 return cast<FieldDecl>(
chain().back());
3328 assert(
chain().size() >= 2);
3329 return dyn_cast<VarDecl>(
chain().front());
3348 mutable const Type *TypeForDecl =
nullptr;
3353 void anchor()
override;
3384 struct alignas(8) ModedTInfo {
3391 mutable llvm::PointerIntPair<
3392 llvm::PointerUnion<TypeSourceInfo *, ModedTInfo *>, 2>
3395 void anchor()
override;
3402 MaybeModedTInfo(TInfo, 0) {}
3430 return MaybeModedTInfo.getPointer().is<ModedTInfo *>();
3434 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->first
3439 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->second
3440 : MaybeModedTInfo.getPointer()
3446 MaybeModedTInfo.setPointer(newType);
3451 ModedTInfo({unmodedTSI, modedTy}));
3468 if (MaybeModedTInfo.getInt())
3469 return MaybeModedTInfo.getInt() & 0x2;
3470 return isTransparentTagSlow();
3476 return K >= firstTypedefName && K <= lastTypedefName;
3480 bool isTransparentTagSlow()
const;
3512 Template(
nullptr) {}
3555 llvm::PointerUnion<TypedefNameDecl *, ExtInfo *> TypedefNameDeclOrQualifier;
3557 bool hasExtInfo()
const {
return TypedefNameDeclOrQualifier.is<
ExtInfo *>(); }
3558 ExtInfo *getExtInfo() {
return TypedefNameDeclOrQualifier.get<ExtInfo *>(); }
3559 const ExtInfo *getExtInfo()
const {
3560 return TypedefNameDeclOrQualifier.get<ExtInfo *>();
3565 SourceLocation L, IdentifierInfo *
Id, TagDecl *PrevDecl,
3566 SourceLocation StartL);
3667 TagDeclBits.IsEmbeddedInDeclarator = isInDeclarator;
3695 return TagDeclBits.IsThisDeclarationADemotedDefinition;
3702 "Should demote definitions only, not forward declarations");
3704 TagDeclBits.IsThisDeclarationADemotedDefinition =
true;
3733 TagDeclBits.TagDeclKind = llvm::to_underlying(TK);
3762 return hasExtInfo() ? nullptr
3834 llvm::PointerUnion<const Type *, TypeSourceInfo *> IntegerType;
3854 bool Scoped,
bool ScopedUsingClassTag,
bool Fixed);
3856 void anchor()
override;
3863 void setNumPositiveBits(
unsigned Num) {
3865 assert(
EnumDeclBits.NumPositiveBits == Num &&
"can't store this bitcount");
3870 void setNumNegativeBits(
unsigned Num) {
EnumDeclBits.NumNegativeBits = Num; }
3891 bool hasODRHash()
const {
return EnumDeclBits.HasODRHash; }
3892 void setHasODRHash(
bool Hash =
true) {
EnumDeclBits.HasODRHash = Hash; }
3905 return cast_or_null<EnumDecl>(
3926 bool IsScoped,
bool IsScopedUsingClassTag,
3941 unsigned NumPositiveBits,
3942 unsigned NumNegativeBits);
3979 if (
const Type *T = IntegerType.dyn_cast<
const Type*>())
3981 return IntegerType.get<
TypeSourceInfo*>()->getType().getUnqualifiedType();
4018 void getValueRange(llvm::APInt &Max, llvm::APInt &Min)
const;
4076 return SpecializationInfo;
4136 return cast_or_null<RecordDecl>(
4220 return RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion;
4321 using field_range = llvm::iterator_range<specific_decl_iterator<FieldDecl>>;
4345 template <
typename Functor>
4348 if (
const auto *FD = dyn_cast<FieldDecl>(D); FD && Pred(FD))
4351 if (
const auto *RD = dyn_cast<RecordDecl>(D))
4352 if (
const FieldDecl *FD = RD->findFieldIf(Pred))
4364 return K >= firstRecord && K <= lastRecord;
4386 void LoadFieldsFromExternalStorage()
const;
4390 void setODRHash(
unsigned Hash) {
RecordDeclBits.ODRHash = Hash; }
4399 :
Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}
4401 virtual void anchor();
4434 Stmt *Statement =
nullptr;
4435 bool IsSemiMissing =
false;
4438 :
Decl(TopLevelStmt, DC, L), Statement(S) {}
4440 virtual void anchor();
4450 assert(IsSemiMissing &&
"Operation supported for printing values only!");
4476 llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;
4485 : VariableAndFlags(variable,
4486 (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
4494 bool isByRef()
const {
return VariableAndFlags.getInt() & flag_isByRef; }
4506 bool isNested()
const {
return VariableAndFlags.getInt() & flag_isNested; }
4518 unsigned NumParams = 0;
4520 Stmt *Body =
nullptr;
4523 const Capture *Captures =
nullptr;
4524 unsigned NumCaptures = 0;
4526 unsigned ManglingNumber = 0;
4527 Decl *ManglingContextDecl =
nullptr;