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;
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");
375 if (isa<EnumDecl>(DC))
438 std::optional<Visibility>
459 if (this->
getKind() != UsingShadow &&
460 this->
getKind() != ConstructorUsingShadow &&
461 this->
getKind() != ObjCCompatibleAlias &&
462 this->
getKind() != NamespaceAlias)
465 return getUnderlyingDeclImpl();
497 bool MSAsmNameResolved =
false;
506 :
NamedDecl(
Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}
508 void anchor()
override;
544 enum Flags :
unsigned { F_Inline = 1 << 0, F_Nested = 1 << 1 };
557 llvm::PointerIntPair<NamespaceDecl *, 2, unsigned>
558 AnonOrFirstNamespaceAndFlags;
606 return AnonOrFirstNamespaceAndFlags.getInt() & F_Inline;
611 unsigned F = AnonOrFirstNamespaceAndFlags.getInt();
613 AnonOrFirstNamespaceAndFlags.setInt(F | F_Inline);
615 AnonOrFirstNamespaceAndFlags.setInt(F & ~F_Inline);
623 return AnonOrFirstNamespaceAndFlags.getInt() & F_Nested;
628 unsigned F = AnonOrFirstNamespaceAndFlags.getInt();
630 AnonOrFirstNamespaceAndFlags.setInt(F | F_Nested);
632 AnonOrFirstNamespaceAndFlags.setInt(F & ~F_Nested);
643 return std::distance(
X.begin(),
X.end()) ==
644 std::distance(Y.begin(), Y.end());
704 void anchor()
override;
709 :
NamedDecl(DK, DC, L, N), DeclType(T) {}
771 Expr *TrailingRequiresClause =
nullptr;
774 llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;
780 bool hasExtInfo()
const {
return DeclInfo.is<ExtInfo*>(); }
781 ExtInfo *getExtInfo() {
return DeclInfo.get<ExtInfo*>(); }
782 const ExtInfo *getExtInfo()
const {
return DeclInfo.get<ExtInfo*>(); }
788 :
ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {}
796 ? getExtInfo()->TInfo
802 getExtInfo()->TInfo = TI;
824 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
832 return hasExtInfo() ? getExtInfo()->QualifierLoc
842 return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
847 return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
854 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
859 return getExtInfo()->TemplParamLists[index];
871 return K >= firstDeclarator && K <= lastDeclarator;
955 using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;
966 class VarDeclBitfields {
971 unsigned TSCSpec : 2;
972 unsigned InitStyle : 2;
976 unsigned ARCPseudoStrong : 1;
978 enum { NumVarDeclBits = 8 };
1000 unsigned HasInheritedDefaultArg : 1;
1009 unsigned IsKNRPromoted : 1;
1012 unsigned IsObjCMethodParam : 1;
1035 unsigned IsThisDeclarationADemotedDefinition : 1;
1039 unsigned ExceptionVar : 1;
1044 unsigned NRVOVariable : 1;
1048 unsigned CXXForRangeDecl : 1;
1051 unsigned ObjCForDecl : 1;
1054 unsigned IsInline : 1;
1057 unsigned IsInlineSpecified : 1;
1060 unsigned IsConstexpr : 1;
1064 unsigned IsInitCapture : 1;
1069 unsigned PreviousDeclInSameBlockScope : 1;
1073 unsigned ImplicitParamKind : 3;
1075 unsigned EscapingByref : 1;
1132 assert(
VarDeclBits.TSCSpec == TSC &&
"truncation");
1214 return DC->getRedeclContext()->isFunctionOrMethod();
1301 if (K == ParmVar || K == ImplicitParam)
1367 bool IsConstantInitialization)
const;
1427 return isa<ParmVarDecl>(
this) ?
false :
1438 assert(!isa<ParmVarDecl>(
this) &&
"Cannot demote ParmVarDecls!");
1448 assert(!isa<ParmVarDecl>(
this));
1466 assert(!isa<ParmVarDecl>(
this));
1476 assert(!isa<ParmVarDecl>(
this));
1505 return isa<ParmVarDecl>(
this) ?
false
1509 assert(!isa<ParmVarDecl>(
this));
1514 assert(!isa<ParmVarDecl>(
this));
1523 assert(!isa<ParmVarDecl>(
this));
1532 assert(!isa<ParmVarDecl>(
this));
1543 return isa<ParmVarDecl>(
this)
1548 assert(!isa<ParmVarDecl>(
this));
1656 void anchor()
override;
1731 :
VarDecl(DK,
C, DC, StartLoc, IdLoc,
Id, T, TInfo, S) {
1752 setParameterIndex(parameterIndex);
1762 setParameterIndex(parameterIndex);
1783 return getParameterIndex();
1878 void setParameterIndex(
unsigned parameterIndex) {
1879 if (parameterIndex >= ParameterIndexSentinel) {
1880 setParameterIndexLarge(parameterIndex);
1885 assert(
ParmVarDeclBits.ParameterIndex == parameterIndex &&
"truncation!");
1887 unsigned getParameterIndex()
const {
1889 return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
1892 void setParameterIndexLarge(
unsigned parameterIndex);
1893 unsigned getParameterIndexLarge()
const;
1945 : llvm::TrailingObjects<DefaultedFunctionInfo, DeclAccessPair> {
1946 friend TrailingObjects;
1947 unsigned NumLookups;
1955 return {getTrailingObjects<DeclAccessPair>(), NumLookups};
2004 TemplateOrSpecialization;
2031 void setFunctionTemplateSpecialization(
ASTContext &
C,
2059 const DeclarationNameInfo &NameInfo, QualType T,
2062 Expr *TrailingRequiresClause =
nullptr);
2098 Expr *TrailingRequiresClause =
nullptr) {
2103 TrailingRequiresClause);
2111 Expr *TrailingRequiresClause);
2127 if (FPT && FPT->isVariadic())
2176 bool CheckForPendingFriendDefinition =
false)
const;
2299 "Can't set default loc is function isn't explicitly defaulted");
2300 DefaultKWLoc = NewLoc;
2306 auto *DeclAsWritten =
this;
2308 DeclAsWritten = Pattern;
2309 return !(DeclAsWritten->isDeleted() ||
2310 DeclAsWritten->getCanonicalDecl()->isDefaulted());
2490 std::optional<unsigned> *AlignmentParam =
nullptr,
2491 bool *IsNothrow =
nullptr)
const;
2598 unsigned getBuiltinID(
bool ConsiderWrapperFunctions =
false)
const;
2626 return ParamInfo[i];
2630 return ParamInfo[i];
2892 setFunctionTemplateSpecialization(
getASTContext(), Template, TemplateArgs,
2893 InsertPos, TSK, TemplateArgsAsWritten,
2894 PointOfInstantiation);
2949 return K >= firstFunction && K <= lastFunction;
2965 enum InitStorageKind {
2981 ISK_CapturedVLAType,
2984 unsigned BitField : 1;
2985 unsigned Mutable : 1;
2986 unsigned StorageKind : 2;
2987 mutable unsigned CachedFieldIndex : 28;
2991 struct InitAndBitWidthStorage {
3022 Mutable(Mutable), StorageKind((InitStorageKind)InitStyle),
3023 CachedFieldIndex(0),
Init() {
3071 "bit width or captured type already set");
3072 assert(Width &&
"no bit width specified");
3084 assert(
isBitField() &&
"no bitfield width to remove");
3088 Init = ExistingInit;
3109 return (StorageKind == ISK_CapturedVLAType ?
ICIS_NoInit
3139 StorageKind = ISK_NoInit;
3150 return StorageKind == ISK_CapturedVLAType;
3196 const llvm::APSInt &
V)
3205 const llvm::APSInt &
V);
3231 unsigned ChainingSize;
3237 void anchor()
override;
3259 assert(
chain().size() >= 2);
3260 return cast<FieldDecl>(
chain().back());
3264 assert(
chain().size() >= 2);
3265 return dyn_cast<VarDecl>(
chain().front());
3284 mutable const Type *TypeForDecl =
nullptr;
3289 void anchor()
override;
3320 struct alignas(8) ModedTInfo {
3327 mutable llvm::PointerIntPair<
3328 llvm::PointerUnion<TypeSourceInfo *, ModedTInfo *>, 2>
3331 void anchor()
override;
3338 MaybeModedTInfo(TInfo, 0) {}
3366 return MaybeModedTInfo.getPointer().is<ModedTInfo *>();
3370 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->first
3375 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->second
3376 : MaybeModedTInfo.getPointer()
3382 MaybeModedTInfo.setPointer(newType);
3387 ModedTInfo({unmodedTSI, modedTy}));
3404 if (MaybeModedTInfo.getInt())
3405 return MaybeModedTInfo.getInt() & 0x2;
3406 return isTransparentTagSlow();
3412 return K >= firstTypedefName && K <= lastTypedefName;
3416 bool isTransparentTagSlow()
const;
3448 Template(
nullptr) {}
3491 llvm::PointerUnion<TypedefNameDecl *, ExtInfo *> TypedefNameDeclOrQualifier;
3493 bool hasExtInfo()
const {
return TypedefNameDeclOrQualifier.is<
ExtInfo *>(); }
3494 ExtInfo *getExtInfo() {
return TypedefNameDeclOrQualifier.get<ExtInfo *>(); }
3495 const ExtInfo *getExtInfo()
const {
3496 return TypedefNameDeclOrQualifier.get<ExtInfo *>();
3501 SourceLocation L, IdentifierInfo *
Id, TagDecl *PrevDecl,
3502 SourceLocation StartL);
3603 TagDeclBits.IsEmbeddedInDeclarator = isInDeclarator;
3631 return TagDeclBits.IsThisDeclarationADemotedDefinition;
3638 "Should demote definitions only, not forward declarations");
3640 TagDeclBits.IsThisDeclarationADemotedDefinition =
true;
3696 return hasExtInfo() ? nullptr
3767 llvm::PointerUnion<const Type *, TypeSourceInfo *> IntegerType;
3787 bool Scoped,
bool ScopedUsingClassTag,
bool Fixed);
3789 void anchor()
override;
3796 void setNumPositiveBits(
unsigned Num) {
3798 assert(
EnumDeclBits.NumPositiveBits == Num &&
"can't store this bitcount");
3803 void setNumNegativeBits(
unsigned Num) {
EnumDeclBits.NumNegativeBits = Num; }
3824 bool hasODRHash()
const {
return EnumDeclBits.HasODRHash; }
3825 void setHasODRHash(
bool Hash =
true) {
EnumDeclBits.HasODRHash = Hash; }
3838 return cast_or_null<EnumDecl>(
3859 bool IsScoped,
bool IsScopedUsingClassTag,
3874 unsigned NumPositiveBits,
3875 unsigned NumNegativeBits);
3912 if (
const Type *T = IntegerType.dyn_cast<
const Type*>())
3914 return IntegerType.get<
TypeSourceInfo*>()->getType().getUnqualifiedType();
3951 void getValueRange(llvm::APInt &Max, llvm::APInt &Min)
const;
4009 return SpecializationInfo;
4068 return cast_or_null<RecordDecl>(
4152 return RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion;
4252 using field_range = llvm::iterator_range<specific_decl_iterator<FieldDecl>>;
4271 return K >= firstRecord && K <= lastRecord;
4293 void LoadFieldsFromExternalStorage()
const;
4297 void setODRHash(
unsigned Hash) {
RecordDeclBits.ODRHash = Hash; }
4306 :
Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}
4308 virtual void anchor();
4341 Stmt *Statement =
nullptr;
4342 bool IsSemiMissing =
false;
4345 :
Decl(TopLevelStmt, DC, L), Statement(S) {}
4347 virtual void anchor();
4357 assert(IsSemiMissing &&
"Operation supported for printing values only!");
4383 llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;
4392 : VariableAndFlags(variable,
4393 (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
4401 bool isByRef()
const {
return VariableAndFlags.getInt() & flag_isByRef; }
4413 bool isNested()
const {
return VariableAndFlags.getInt() & flag_isNested; }
4425 unsigned NumParams = 0;
4427 Stmt *Body =
nullptr;
4430 const Capture *Captures =
nullptr;
4431 unsigned NumCaptures = 0;
4433 unsigned ManglingNumber = 0;
4434 Decl *ManglingContextDecl =
nullptr;
4478 return ParamInfo[i];
4482 return ParamInfo[i];