55#include "llvm/ADT/APSInt.h"
56#include "llvm/ADT/ArrayRef.h"
57#include "llvm/ADT/STLExtras.h"
58#include "llvm/ADT/SmallVector.h"
59#include "llvm/ADT/StringRef.h"
60#include "llvm/ADT/StringSwitch.h"
61#include "llvm/Support/Casting.h"
62#include "llvm/Support/ErrorHandling.h"
63#include "llvm/Support/raw_ostream.h"
64#include "llvm/TargetParser/Triple.h"
90 if (
auto *ND = dyn_cast_if_present<NamedDecl>(TheDecl)) {
104TranslationUnitDecl::TranslationUnitDecl(
ASTContext &ctx)
106 DeclContext(TranslationUnit), redeclarable_base(ctx), Ctx(ctx) {}
168 Kind.IgnoreExplicitVisibility =
true;
174 assert(!kind.IgnoreExplicitVisibility &&
175 "asking for explicit visibility when we shouldn't be");
176 return D->getExplicitVisibility(kind.getExplicitVisibilityKind());
182 return isa<TypeDecl>(
D) ||
183 isa<ClassTemplateDecl>(
D) ||
184 isa<ObjCInterfaceDecl>(
D);
190static std::enable_if_t<!std::is_base_of_v<RedeclarableTemplateDecl, T>,
bool>
193 D->getMemberSpecializationInfo()) {
194 return member->isExplicitSpecialization();
203 return D->isMemberSpecialization();
210 switch (
attr->getVisibility()) {
218 llvm_unreachable(
"bad visibility kind");
222static std::optional<Visibility>
227 if (
const auto *A =
D->
getAttr<TypeVisibilityAttr>()) {
233 if (
const auto *A =
D->
getAttr<VisibilityAttr>()) {
250LinkageInfo LinkageComputer::getLVForTemplateParameterList(
256 if (isa<TemplateTypeParmDecl>(
P))
263 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
P)) {
265 if (!NTTP->isExpandedParameterPack()) {
266 if (!NTTP->getType()->isDependentType()) {
267 LV.
merge(getLVForType(*NTTP->getType(), computation));
273 for (
unsigned i = 0, n = NTTP->getNumExpansionTypes(); i != n; ++i) {
275 if (!
type->isDependentType())
283 const auto *TTP = cast<TemplateTemplateParmDecl>(
P);
286 if (!TTP->isExpandedParameterPack()) {
287 LV.
merge(getLVForTemplateParameterList(TTP->getTemplateParameters(),
293 for (
unsigned i = 0, n = TTP->getNumExpansionTemplateParameters();
295 LV.
merge(getLVForTemplateParameterList(
296 TTP->getExpansionTemplateParameters(i), computation));
304 const Decl *Ret =
nullptr;
306 while (DC->
getDeclKind() != Decl::TranslationUnit) {
307 if (isa<FunctionDecl>(DC) || isa<BlockDecl>(DC))
308 Ret = cast<Decl>(DC);
325 switch (Arg.getKind()) {
332 LV.
merge(getLVForType(*Arg.getAsType(), computation));
347 LV.
merge(getLVForValue(Arg.getAsStructuralValue(), computation));
353 Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl())
358 LV.
merge(getLVForTemplateArgumentList(Arg.getPackAsArray(), computation));
361 llvm_unreachable(
"bad template argument kind");
370 return getLVForTemplateArgumentList(TArgs.
asArray(), computation);
382 return !fn->
hasAttr<VisibilityAttr>();
392void LinkageComputer::mergeTemplateLV(
396 bool considerVisibility =
413 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
466void LinkageComputer::mergeTemplateLV(
489 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
490 if (considerVisibility)
523void LinkageComputer::mergeTemplateLV(
LinkageInfo &LV,
540 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
541 if (considerVisibility)
549 if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden)
552 const auto *FD = dyn_cast<FunctionDecl>(
D);
558 = FD->getTemplateSpecializationInfo()) {
561 FD->getMemberSpecializationInfo()) {
562 TSK = MSI->getTemplateSpecializationKind();
575 const T *
First =
D->getFirstDecl();
576 return First->isInExternCContext();
581 if (!SD->hasBraces())
588 return M->isInterfaceOrPartition();
597 if (
auto *TD = dyn_cast<TemplateDecl>(
D))
598 D = TD->getTemplatedDecl();
600 if (
auto *VD = dyn_cast<VarDecl>(
D))
601 return VD->getStorageClass();
602 if (
auto *FD = dyn_cast<FunctionDecl>(
D))
603 return FD->getStorageClass();
609LinkageComputer::getLVForNamespaceScopeDecl(
const NamedDecl *
D,
611 bool IgnoreVarTypeLinkage) {
613 "Not a name having namespace scope");
615 const auto *Var = dyn_cast<VarDecl>(
D);
622 (Context.
getLangOpts().C23 && Var && Var->isConstexpr())) {
643 if (Context.
getLangOpts().CPlusPlus && Var->getType().isConstQualified() &&
644 !Var->getType().isVolatileQualified() && !Var->isInline() &&
646 !isa<VarTemplateSpecializationDecl>(Var) &&
647 !Var->getDescribedVarTemplate()) {
652 if (Var->getStorageClass() !=
SC_Extern &&
661 Var->getStorageClass() ==
SC_None)
667 }
else if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(
D)) {
669 const VarDecl *VD = IFD->getVarDecl();
670 assert(VD &&
"Expected a VarDecl in this IndirectFieldDecl!");
671 return getLVForNamespaceScopeDecl(VD, computation, IgnoreVarTypeLinkage);
673 assert(!isa<FieldDecl>(
D) &&
"Didn't expect a FieldDecl!");
678 const auto *Var = dyn_cast<VarDecl>(
D);
679 const auto *
Func = dyn_cast<FunctionDecl>(
D);
707 !isa<TranslationUnitDecl>(DC);
709 const auto *ND = dyn_cast<NamespaceDecl>(DC);
711 if (std::optional<Visibility> Vis =
751 if (
const auto *Var = dyn_cast<VarDecl>(
D)) {
775 !IgnoreVarTypeLinkage) {
776 LinkageInfo TypeLV = getLVForType(*Var->getType(), computation);
793 if (
const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
794 mergeTemplateLV(LV, spec, computation);
798 }
else if (
const auto *
Function = dyn_cast<FunctionDecl>(
D)) {
814 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(
Function)))
830 TypeAsWritten = TSI->getType();
839 =
Function->getTemplateSpecializationInfo()) {
840 mergeTemplateLV(LV,
Function, specInfo, computation);
849 }
else if (
const auto *Tag = dyn_cast<TagDecl>(
D)) {
851 if (!
Tag->hasNameForLinkage())
857 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
858 mergeTemplateLV(LV, spec, computation);
863 }
else if (isa<EnumConstantDecl>(
D)) {
871 }
else if (
const auto *temp = dyn_cast<TemplateDecl>(
D)) {
882 }
else if (isa<NamespaceDecl>(
D)) {
887 }
else if (isa<ObjCInterfaceDecl>(
D)) {
890 }
else if (
auto *TD = dyn_cast<TypedefNameDecl>(
D)) {
893 if (!TD->getAnonDeclWithTypedefName(
true))
896 }
else if (isa<MSGuidDecl>(
D)) {
914LinkageComputer::getLVForClassMember(
const NamedDecl *
D,
916 bool IgnoreVarTypeLinkage) {
927 if (!(isa<CXXMethodDecl>(
D) ||
930 isa<IndirectFieldDecl>(
D) ||
932 isa<TemplateDecl>(
D)))
970 const NamedDecl *explicitSpecSuppressor =
nullptr;
972 if (
const auto *MD = dyn_cast<CXXMethodDecl>(
D)) {
975 QualType TypeAsWritten = MD->getType();
977 TypeAsWritten = TSI->getType();
984 = MD->getTemplateSpecializationInfo()) {
985 mergeTemplateLV(LV, MD, spec, computation);
987 explicitSpecSuppressor = MD;
989 explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl();
992 explicitSpecSuppressor = MD;
1003 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(MD)))
1006 }
else if (
const auto *RD = dyn_cast<CXXRecordDecl>(
D)) {
1007 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
1008 mergeTemplateLV(LV, spec, computation);
1010 explicitSpecSuppressor = spec;
1018 explicitSpecSuppressor = RD;
1022 }
else if (
const auto *VD = dyn_cast<VarDecl>(
D)) {
1023 if (
const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(VD))
1024 mergeTemplateLV(LV, spec, computation);
1028 if (!IgnoreVarTypeLinkage) {
1038 explicitSpecSuppressor = VD;
1042 }
else if (
const auto *temp = dyn_cast<TemplateDecl>(
D)) {
1043 bool considerVisibility =
1051 if (
const auto *redeclTemp = dyn_cast<RedeclarableTemplateDecl>(temp)) {
1059 assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor));
1063 bool considerClassVisibility =
true;
1064 if (explicitSpecSuppressor &&
1069 considerClassVisibility =
false;
1077void NamedDecl::anchor() {}
1100 if (isa<FieldDecl>(
this))
1102 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(
this)) {
1106 const VarDecl *VD = IFD->getVarDecl();
1110 if (
const auto *VD = dyn_cast<VarDecl>(
this)) {
1111 if (isa<ParmVarDecl>(VD))
1117 if (
const auto *BD = dyn_cast<BindingDecl>(
this);
1119 const VarDecl *VD = BD->getHoldingVar();
1151 if (
auto *VD = dyn_cast<VarDecl>(
this))
1154 if (
auto *FD = dyn_cast<FunctionDecl>(
this))
1155 if (FD->isExternC())
1167 if (name.front() ==
'C')
1168 if (name ==
"CFStringCreateWithFormat" ||
1169 name ==
"CFStringCreateWithFormatAndArguments" ||
1170 name ==
"CFStringAppendFormat" ||
1171 name ==
"CFStringAppendFormatAndArguments")
1195 llvm_unreachable(
"unexpected module ownership kind");
1214 !isa<NamespaceDecl>(
this))
1224static std::optional<Visibility>
1227 bool IsMostRecent) {
1236 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
1238 if (InstantiatedFrom)
1245 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
1249 while (TD !=
nullptr) {
1251 if (Vis != std::nullopt)
1253 TD = TD->getPreviousDecl();
1255 return std::nullopt;
1259 if (!IsMostRecent && !isa<NamespaceDecl>(ND)) {
1261 if (MostRecent != ND)
1265 if (
const auto *Var = dyn_cast<VarDecl>(ND)) {
1266 if (Var->isStaticDataMember()) {
1268 if (InstantiatedFrom)
1272 if (
const auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Var))
1273 return getVisibilityOf(VTSD->getSpecializedTemplate()->getTemplatedDecl(),
1276 return std::nullopt;
1279 if (
const auto *fn = dyn_cast<FunctionDecl>(ND)) {
1284 return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(),
1290 if (InstantiatedFrom)
1293 return std::nullopt;
1297 if (
const auto *TD = dyn_cast<TemplateDecl>(ND))
1300 return std::nullopt;
1303std::optional<Visibility>
1314 Owner = dyn_cast<NamedDecl>(DC);
1315 else if (isa<ParmVarDecl>(ContextDecl))
1318 else if (isa<ImplicitConceptSpecializationDecl>(ContextDecl)) {
1323 Owner = cast<NamedDecl>(ContextDecl);
1333 auto *VD = dyn_cast<VarDecl>(Owner);
1349 if (
const auto *
Function = dyn_cast<FunctionDecl>(
D)) {
1350 if (
Function->isInAnonymousNamespace() &&
1360 if (std::optional<Visibility> Vis =
1372 if (
const auto *Var = dyn_cast<VarDecl>(
D)) {
1373 if (Var->hasExternalStorage()) {
1381 if (std::optional<Visibility> Vis =
1396 if (!Var->isStaticLocal())
1409 if (
const auto *BD = dyn_cast<BlockDecl>(OuterD)) {
1410 if (!BD->getBlockManglingNumber())
1413 LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(),
1414 BD->getBlockManglingContextDecl(), computation);
1416 const auto *FD = cast<FunctionDecl>(OuterD);
1417 if (!FD->isInlined() &&
1427 !Context.
getLangOpts().VisibilityInlinesHiddenStaticLocalVar) {
1428 assert(cast<VarDecl>(
D)->isStaticLocal());
1432 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1452 bool IgnoreVarTypeLinkage) {
1454 if (
D->
hasAttr<InternalLinkageAttr>())
1469 case Decl::ImplicitParam:
1471 case Decl::NamespaceAlias:
1474 case Decl::UsingEnum:
1475 case Decl::UsingShadow:
1476 case Decl::UsingDirective:
1479 case Decl::EnumConstant:
1486 case Decl::TypeAlias:
1489 if (!cast<TypedefNameDecl>(
D)
1490 ->getAnonDeclWithTypedefName(
true))
1494 case Decl::TemplateTemplateParm:
1495 case Decl::NonTypeTemplateParm:
1496 case Decl::ObjCAtDefsField:
1497 case Decl::ObjCCategory:
1498 case Decl::ObjCCategoryImpl:
1499 case Decl::ObjCCompatibleAlias:
1500 case Decl::ObjCImplementation:
1501 case Decl::ObjCMethod:
1502 case Decl::ObjCProperty:
1503 case Decl::ObjCPropertyImpl:
1504 case Decl::ObjCProtocol:
1507 case Decl::CXXRecord: {
1508 const auto *
Record = cast<CXXRecordDecl>(
D);
1509 if (
Record->isLambda()) {
1510 if (
Record->hasKnownLambdaInternalLinkage() ||
1511 !
Record->getLambdaManglingNumber()) {
1516 return getLVForClosure(
1517 Record->getDeclContext()->getRedeclContext(),
1518 Record->getLambdaContextDecl(), computation);
1524 case Decl::TemplateParamObject: {
1527 auto *TPO = cast<TemplateParamObjectDecl>(
D);
1528 LinkageInfo LV = getLVForType(*TPO->getType(), computation);
1529 LV.
merge(getLVForValue(TPO->getValue(), computation));
1536 return getLVForNamespaceScopeDecl(
D, computation, IgnoreVarTypeLinkage);
1546 return getLVForClassMember(
D, computation, IgnoreVarTypeLinkage);
1560 return getLVForLocalDecl(
D, computation);
1571 if (
D->
hasAttr<InternalLinkageAttr>())
1577 if (std::optional<LinkageInfo> LI = lookup(
D, computation))
1585 cache(
D, computation, LV);
1592 if (!Opts.CPlusPlus || Opts.MicrosoftExt)
1600 auto *
T = cast<NamedDecl>(I);
1603 if (!
T->isInvalidDecl() &&
T->hasCachedLinkage()) {
1625 if (isa<NamespaceDecl>(
this))
1657 llvm_unreachable(
"unknown module kind");
1661 Name.
print(OS, Policy);
1669 std::string QualName;
1670 llvm::raw_string_ostream OS(QualName);
1693 llvm::raw_svector_ostream NameOS(NameBuffer);
1695 if (NameBuffer.empty())
1696 OS <<
"(anonymous)";
1712 if (
auto *MD = dyn_cast<ObjCMethodDecl>(
this)) {
1713 if (
auto *ID = MD->getClassInterface())
1715 }
else if (
auto *PD = dyn_cast<ObjCPropertyDecl>(
this)) {
1716 if (
auto *MD = PD->getGetterMethodDecl())
1717 if (
auto *ID = MD->getClassInterface())
1719 }
else if (
auto *ID = dyn_cast<ObjCIvarDecl>(
this)) {
1720 if (
auto *CI = ID->getContainingInterface())
1728 ContextsTy Contexts;
1734 if (
P.SuppressUnwrittenScope && isa<NamespaceDecl>(Ctx) &&
1735 cast<NamespaceDecl>(Ctx)->isAnonymousNamespace())
1740 cast<NamespaceDecl>(Ctx)->isRedundantInlineQualifierFor(NameInScope))
1744 const NamedDecl *ND = dyn_cast<NamedDecl>(Ctx);
1748 Contexts.push_back(Ctx);
1752 for (
const DeclContext *DC : llvm::reverse(Contexts)) {
1753 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1754 OS << Spec->getName();
1758 Spec->getSpecializedTemplate()->getTemplateParameters());
1759 }
else if (
const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
1760 if (ND->isAnonymousNamespace()) {
1761 OS << (
P.MSVCFormatting ?
"`anonymous namespace\'"
1762 :
"(anonymous namespace)");
1766 }
else if (
const auto *RD = dyn_cast<RecordDecl>(DC)) {
1767 if (!RD->getIdentifier())
1768 OS <<
"(anonymous " << RD->getKindName() <<
')';
1771 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(DC)) {
1773 if (FD->hasWrittenPrototype())
1774 FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<
FunctionType>());
1778 unsigned NumParams = FD->getNumParams();
1779 for (
unsigned i = 0; i < NumParams; ++i) {
1782 OS << FD->getParamDecl(i)->getType().stream(
P);
1792 }
else if (
const auto *ED = dyn_cast<EnumDecl>(DC)) {
1805 OS << *cast<NamedDecl>(DC);
1826#define DECL(Type, Base) \
1828 return isRedeclarableImpl((Type##Decl *)nullptr);
1829#define ABSTRACT_DECL(DECL)
1830#include "clang/AST/DeclNodes.inc"
1832 llvm_unreachable(
"unknown decl kind");
1836 bool IsKnownNewer)
const {
1849 if (isa<ObjCMethodDecl>(
this))
1854 if (isa<ParmVarDecl>(
this))
1866 if (
const auto *UD = dyn_cast<UsingDecl>(
this)) {
1870 cast<UsingDecl>(OldD)->getQualifier());
1872 if (
const auto *UUVD = dyn_cast<UnresolvedUsingValueDecl>(
this)) {
1876 cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
1915 llvm_unreachable(
"Linkage hasn't been computed!");
1922 llvm_unreachable(
"Non-formal linkage is not allowed here!");
1927 llvm_unreachable(
"Unhandled Linkage enum");
1930NamedDecl *NamedDecl::getUnderlyingDeclImpl() {
1932 if (
auto *UD = dyn_cast<UsingShadowDecl>(ND))
1933 ND = UD->getTargetDecl();
1935 if (
auto *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND))
1936 return AD->getClassInterface();
1938 if (
auto *AD = dyn_cast<NamespaceAliasDecl>(ND))
1939 return AD->getNamespace();
1949 if (isa<UsingShadowDecl>(
D))
1950 D = cast<UsingShadowDecl>(
D)->getTargetDecl();
1952 if (isa<FieldDecl>(
D) || isa<IndirectFieldDecl>(
D) || isa<MSPropertyDecl>(
D))
1954 if (
const auto *MD = dyn_cast_if_present<CXXMethodDecl>(
D->
getAsFunction()))
1955 return MD->isInstance();
1963template <
typename DeclT>
1965 if (
decl->getNumTemplateParameterLists() > 0)
1966 return decl->getTemplateParameterList(0)->getTemplateLoc();
1967 return decl->getInnerLocStart();
1985 if (!hasExtInfo()) {
1991 getExtInfo()->TInfo = savedTInfo;
1994 getExtInfo()->QualifierLoc = QualifierLoc;
1995 }
else if (hasExtInfo()) {
1997 getExtInfo()->QualifierLoc = QualifierLoc;
2002 assert(TrailingRequiresClause);
2004 if (!hasExtInfo()) {
2010 getExtInfo()->TInfo = savedTInfo;
2013 getExtInfo()->TrailingRequiresClause = TrailingRequiresClause;
2018 assert(!TPLists.empty());
2020 if (!hasExtInfo()) {
2026 getExtInfo()->TInfo = savedTInfo;
2029 getExtInfo()->setTemplateParameterListsInfo(Context, TPLists);
2047 case Type::BlockPointer:
2050 case Type::MemberPointer:
2053 case Type::LValueReference:
2054 case Type::RValueReference:
2057 case Type::PackExpansion:
2058 QT = cast<PackExpansionType>(
T)->getPattern();
2061 case Type::ConstantArray:
2062 case Type::DependentSizedArray:
2063 case Type::IncompleteArray:
2064 case Type::VariableArray:
2065 case Type::FunctionProto:
2066 case Type::FunctionNoProto:
2078 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
2092 if (!TPLists.empty()) {
2113 llvm_unreachable(
"Invalid storage class");
2122 static_assert(
sizeof(VarDeclBitfields) <=
sizeof(
unsigned),
2123 "VarDeclBitfields too large!");
2125 "ParmVarDeclBitfields too large!");
2127 "NonParmVarDeclBitfields too large!");
2136 return new (
C, DC)
VarDecl(Var,
C, DC, StartL, IdL,
Id,
T, TInfo, S);
2153 if (!hasAttr<ThreadAttr>() &&
2156 hasAttr<OMPThreadPrivateDeclAttr>()))
2160 hasAttr<OMPThreadPrivateDeclAttr>())
2169 llvm_unreachable(
"Unknown thread storage class specifier!");
2187 if (!
D.hasExternalFormalLinkage())
2271 isa<VarTemplatePartialSpecializationDecl>(
this)))
2290 if (
const auto *SAA = getAttr<SelectAnyAttr>())
2291 if (!SAA->isInherited())
2297 if (
auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(
this)) {
2299 !isa<VarTemplatePartialSpecializationDecl>(VTSD) &&
2300 !VTSD->IsCompleteDefinition)
2332 VarDecl *LastTentative =
nullptr;
2337 Kind =
Decl->isThisDeclarationADefinition();
2342 LastTentative =
Decl;
2345 return LastTentative;
2351 if (I->isThisDeclarationADefinition(
C) ==
Definition)
2362 Kind = std::max(
Kind, I->isThisDeclarationADefinition(
C));
2372 if (
auto Expr = I->getInit()) {
2381 if (
auto *
P = dyn_cast<ParmVarDecl>(
this))
2382 if (
P->hasUnparsedDefaultArg() ||
P->hasUninstantiatedDefaultArg())
2386 return Eval->Value.isValid();
2388 return !
Init.isNull();
2395 if (
auto *S =
Init.dyn_cast<
Stmt *>())
2396 return cast<Expr>(S);
2400 return cast<Expr>(Eval->Value.get(
2401 Eval->Value.isOffset() ?
getASTContext().getExternalSource() :
nullptr));
2406 return ES->Value.getAddressOfPointer(
getASTContext().getExternalSource());
2408 return Init.getAddrOfPtr1();
2417 if (I->isThisDeclarationADefinition()) {
2444 Eval->~EvaluatedStmt();
2456 if (!Lang.CPlusPlus && !Lang.OpenCL && !Lang.C23)
2460 if (isa<ParmVarDecl>(
this))
2469 if (Lang.CPlusPlus11 &&
getType()->isReferenceType())
2480 if (
getType()->isIntegralOrEnumerationType() && !Lang.C23)
2490 return (Lang.CPlusPlus11 || Lang.C23) &&
isConstexpr();
2497 const VarDecl *DefVD =
nullptr;
2499 if (!
Init ||
Init->isValueDependent() ||
getType()->isDependentType())
2545 bool IsConstantInitialization)
const {
2549 assert(!
Init->isValueDependent());
2566 IsConstantInitialization);
2572 if (IsConstantInitialization &&
2602 assert(
Init &&
"no initializer");
2632 "already evaluated var value before checking for constant init");
2635 "only meaningful in C++/C23");
2637 assert(!
getInit()->isValueDependent());
2641 evaluateValueImpl(Notes,
true) && Notes.empty();
2652 return isa<PackExpansionType>(
getType());
2655template<
typename DeclT>
2658 if (
auto *Def =
D->getDefinition())
2674 llvm::any_of(specific_attrs<AlignedAttr>(), [](
const AlignedAttr *AA) {
2675 return AA->isAlignmentDependent();
2694 if (
auto *VDTemplSpec = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2696 auto From = VDTemplSpec->getInstantiatedFrom();
2698 while (!VTD->isMemberSpecialization()) {
2699 auto *NewVTD = VTD->getInstantiatedFromMemberTemplate();
2708 while (!VTPSD->isMemberSpecialization()) {
2709 auto *NewVTPSD = VTPSD->getInstantiatedFromMember();
2714 return getDefinitionOrSelf<VarDecl>(VTPSD);
2722 while (!VarTemplate->isMemberSpecialization()) {
2723 auto *NewVT = VarTemplate->getInstantiatedFromMemberTemplate();
2726 VarTemplate = NewVT;
2739 return cast<VarDecl>(MSI->getInstantiatedFrom());
2745 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2746 return Spec->getSpecializationKind();
2749 return MSI->getTemplateSpecializationKind();
2757 return MSI->getTemplateSpecializationKind();
2759 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2760 return Spec->getSpecializationKind();
2766 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2767 return Spec->getPointOfInstantiation();
2770 return MSI->getPointOfInstantiation();
2793 if (LangOpts.CUDA && !LangOpts.GPURelocatableDeviceCode &&
2795 isa<IncompleteArrayType>(
getType()))
2804 !hasAttr<AlwaysDestroyAttr>()));
2820 assert(
hasInit() &&
"Expect initializer to check for flexible array init");
2822 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2824 auto *List = dyn_cast<InitListExpr>(
getInit()->IgnoreParens());
2827 const Expr *FlexibleInit = List->getInit(List->getNumInits() - 1);
2835 assert(
hasInit() &&
"Expect initializer to check for flexible array init");
2837 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2839 auto *List = dyn_cast<InitListExpr>(
getInit()->IgnoreParens());
2840 if (!List || List->getNumInits() == 0)
2842 const Expr *FlexibleInit = List->getInit(List->getNumInits() - 1);
2850 if (FlexibleArrayOffset + FlexibleArraySize < RL.
getSize())
2852 return FlexibleArrayOffset + FlexibleArraySize - RL.
getSize();
2866 assert((isa<VarTemplateSpecializationDecl>(
this) ||
2868 "not a variable or static data member template specialization");
2871 dyn_cast<VarTemplateSpecializationDecl>(
this)) {
2872 Spec->setSpecializationKind(TSK);
2874 PointOfInstantiation.
isValid() &&
2875 Spec->getPointOfInstantiation().isInvalid()) {
2876 Spec->setPointOfInstantiation(PointOfInstantiation);
2878 L->InstantiationRequested(
this);
2881 MSI->setTemplateSpecializationKind(TSK);
2883 MSI->getPointOfInstantiation().isInvalid()) {
2884 MSI->setPointOfInstantiation(PointOfInstantiation);
2886 L->InstantiationRequested(
this);
2894 assert(
getASTContext().getTemplateOrSpecializationInfo(
this).isNull() &&
2895 "Previous template or instantiation?");
2908 return new (
C, DC)
ParmVarDecl(ParmVar,
C, DC, StartLoc, IdLoc,
Id,
T, TInfo,
2915 if (
const auto *DT = dyn_cast<DecayedType>(
T))
2916 return DT->getOriginalType();
2943 if (hasAttr<NSConsumedAttr>())
2949 if (RT && RT->getDecl()->isParamDestroyedInCallee() &&
2959 "Default argument is not yet instantiated!");
2962 if (
auto *
E = dyn_cast_if_present<FullExpr>(Arg))
2963 return E->getSubExpr();
2990 llvm_unreachable(
"Invalid default argument kind.");
3000 "Wrong kind of initialization expression!");
3001 return cast_if_present<Expr>(
Init.get<
Stmt *>());
3012void ParmVarDecl::setParameterIndexLarge(
unsigned parameterIndex) {
3017unsigned ParmVarDecl::getParameterIndexLarge()
const {
3029 bool UsesFPIntrin,
bool isInlineSpecified,
3031 Expr *TrailingRequiresClause)
3035 EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.
getInfo()) {
3065 if (TrailingRequiresClause)
3078 if (
const auto *FT =
getType()->getAs<FunctionProtoType>())
3079 return FT->isVariadic();
3087 static constexpr size_t Alignment =
3090 size_t Size = totalSizeToAlloc<DeclAccessPair, StringLiteral *>(
3091 Lookups.size(), DeletedMessage !=
nullptr);
3095 Info->NumLookups = Lookups.size();
3096 Info->HasDeletedMessage = DeletedMessage !=
nullptr;
3098 std::uninitialized_copy(Lookups.begin(), Lookups.end(),
3101 *Info->getTrailingObjects<
StringLiteral *>() = DeletedMessage;
3107 assert(!
FunctionDeclBits.HasDefaultedOrDeletedInfo &&
"already have this");
3108 assert(!
Body &&
"can't replace function body with defaulted function info");
3133 assert(HasDeletedMessage &&
3134 "No space to store a delete message in this DefaultedOrDeletedInfo");
3135 *getTrailingObjects<StringLiteral *>() = Message;
3145 for (
const auto *I :
redecls()) {
3146 if (I->doesThisDeclarationHaveABody()) {
3163 if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
3176 return InstantiatedFrom->getFriendObjectKind() &&
3177 InstantiatedFrom->isThisDeclarationADefinition();
3184 return InstantiatedFrom->getFriendObjectKind() &&
3185 InstantiatedFrom->isThisDeclarationADefinition();
3192 bool CheckForPendingFriendDefinition)
const {
3194 if (FD->isThisDeclarationADefinition()) {
3214 if (CheckForPendingFriendDefinition &&
3215 FD->isThisDeclarationInstantiatedFromAFriendDefinition()) {
3228 assert(!
Definition->FunctionDeclBits.HasDefaultedOrDeletedInfo &&
3229 "definition should not have a body");
3247 Parent->markedVirtualFunctionPure();
3250template<std::
size_t Len>
3253 return II && II->
isStr(Str);
3287 if (
const auto *MD = dyn_cast<CXXMethodDecl>(
this);
3288 MD && MD->isLambdaStaticInvoker())
3289 return MD->getParent()->getLambdaCallOperator()->isImmediateFunction();
3319 return llvm::StringSwitch<bool>(
getName())
3332 if (
getDeclName().getCXXOverloadedOperator() != OO_New &&
3333 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3334 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3335 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3342 if (proto->getNumParams() != 2 || proto->isVariadic())
3351 return (proto->getParamType(1).getCanonicalType() == Context.
VoidPtrTy);
3355 std::optional<unsigned> *AlignmentParam,
bool *IsNothrow)
const {
3358 if (
getDeclName().getCXXOverloadedOperator() != OO_New &&
3359 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3360 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3361 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3372 if (FPT->getNumParams() == 0 || FPT->getNumParams() > 4 || FPT->isVariadic())
3377 if (FPT->getNumParams() == 1)
3380 unsigned Params = 1;
3381 QualType Ty = FPT->getParamType(Params);
3384 auto Consume = [&] {
3386 Ty = Params < FPT->getNumParams() ? FPT->getParamType(Params) :
QualType();
3390 bool IsSizedDelete =
false;
3392 (
getDeclName().getCXXOverloadedOperator() == OO_Delete ||
3393 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete) &&
3395 IsSizedDelete =
true;
3404 *AlignmentParam = Params;
3427 T = TD->getDecl()->getUnderlyingType();
3430 if (II && II->
isStr(
"__hot_cold_t"))
3434 return Params == FPT->getNumParams();
3459 llvm_unreachable(
"Unknown GVALinkage");
3473 RD->getIdentifier()->isStr(
"destroying_delete_t");
3485 if (hasAttr<OpenCLKernelAttr>())
3495 if (
const auto *Method = dyn_cast<CXXMethodDecl>(
this))
3496 return Method->isStatic();
3504 if (
const auto *Namespace = cast<NamespaceDecl>(DC)) {
3505 if (!Namespace->getDeclName())
3514 if (hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
3515 hasAttr<C11NoReturnAttr>())
3518 if (
auto *FnTy =
getType()->getAs<FunctionType>())
3519 return FnTy->getNoReturnAttr();
3547 if (hasAttr<TargetAttr>())
3549 if (hasAttr<TargetVersionAttr>())
3551 if (hasAttr<CPUDispatchAttr>())
3553 if (hasAttr<CPUSpecificAttr>())
3555 if (hasAttr<TargetClonesAttr>())
3570 (hasAttr<TargetAttr>() || hasAttr<TargetVersionAttr>());
3576 if (hasAttr<TargetAttr>())
3577 return getAttr<TargetAttr>()->isDefaultVersion();
3578 return hasAttr<TargetVersionAttr>() &&
3579 getAttr<TargetVersionAttr>()->isDefaultVersion();
3597 assert((!PrevDecl || PrevFunTmpl) &&
"Function/function template mismatch");
3598 FunTmpl->setPreviousDecl(PrevFunTmpl);
3621 unsigned BuiltinID = 0;
3623 if (
const auto *ABAA = getAttr<ArmBuiltinAliasAttr>()) {
3624 BuiltinID = ABAA->getBuiltinName()->getBuiltinID();
3625 }
else if (
const auto *BAA = getAttr<BuiltinAliasAttr>()) {
3626 BuiltinID = BAA->getBuiltinName()->getBuiltinID();
3627 }
else if (
const auto *A = getAttr<BuiltinAttr>()) {
3628 BuiltinID = A->getID();
3636 if (!ConsiderWrapperFunctions && hasAttr<OverloadableAttr>() &&
3637 (!hasAttr<ArmBuiltinAliasAttr>() && !hasAttr<BuiltinAliasAttr>()))
3660 if (Context.
getLangOpts().CUDA && hasAttr<CUDADeviceAttr>() &&
3661 !hasAttr<CUDAHostAttr>() &&
3662 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3671 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3687 assert(!ParamInfo &&
"Already has param info!");
3688 assert(NewParamInfo.size() ==
getNumParams() &&
"Parameter count mismatch!");
3691 if (!NewParamInfo.empty()) {
3693 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
3707 unsigned NumRequiredArgs = 0;
3708 unsigned MinParamsSoFar = 0;
3710 if (!Param->isParameterPack()) {
3712 if (!Param->hasDefaultArg())
3713 NumRequiredArgs = MinParamsSoFar;
3716 return NumRequiredArgs;
3746 assert(
isInlined() &&
"expected to get called on an inlined function!");
3750 !hasAttr<DLLExportAttr>())
3755 if (!FD->isImplicit() && FD->getStorageClass() ==
SC_Extern)
3767 if (!FD->isImplicit() && FD->getStorageClass() ==
SC_Extern)
3797 "Must have a declaration without a body.");
3811 if (Context.
getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3821 bool FoundBody =
false;
3846 bool FoundBody =
false;
3871 !
SM.isBeforeInTranslationUnit(RTRange.
getEnd(), Boundary))
3917 hasAttr<AliasAttr>()) &&
3918 "Must be a function definition");
3919 assert(
isInlined() &&
"Function must be inline");
3922 if (Context.
getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3936 for (
auto *Redecl :
redecls()) {
3937 if (Redecl->isInlineSpecified() &&
3947 "should not use C inline rules in C++");
3953 for (
auto *Redecl :
redecls()) {
3982 if (TemplateOrSpecialization.isNull())
3984 if (
const auto *ND = TemplateOrSpecialization.dyn_cast<
NamedDecl *>()) {
3985 if (isa<FunctionDecl>(ND))
3987 assert(isa<FunctionTemplateDecl>(ND) &&
3988 "No other valid types in NamedDecl");
3995 if (TemplateOrSpecialization.is
3999 llvm_unreachable(
"Did we miss a TemplateOrSpecialization type?");
4004 return cast<FunctionDecl>(Info->getInstantiatedFrom());
4013 if (
auto *FTSI = TemplateOrSpecialization
4014 .dyn_cast<FunctionTemplateSpecializationInfo *>())
4015 return FTSI->getMemberSpecializationInfo();
4020FunctionDecl::setInstantiationOfMemberFunction(
ASTContext &
C,
4023 assert(TemplateOrSpecialization.isNull() &&
4024 "Member function is already a specialization");
4027 TemplateOrSpecialization = Info;
4031 return dyn_cast_if_present<FunctionTemplateDecl>(
4032 TemplateOrSpecialization.dyn_cast<
NamedDecl *>());
4037 assert(TemplateOrSpecialization.isNull() &&
4038 "Member function is already a specialization");
4039 TemplateOrSpecialization = Template;
4044 TemplateOrSpecialization
4045 .is<DependentFunctionTemplateSpecializationInfo *>();
4049 assert(TemplateOrSpecialization.isNull() &&
4050 "Function is already a specialization");
4051 TemplateOrSpecialization = FD;
4055 return dyn_cast_if_present<FunctionDecl>(
4056 TemplateOrSpecialization.dyn_cast<
NamedDecl *>());
4080 bool HasPattern =
false;
4082 HasPattern = PatternDecl->
hasBody(PatternDecl);
4088 if (!HasPattern || !PatternDecl)
4112 dyn_cast<CXXMethodDecl>(
this))) {
4124 if (ForDefinition &&
4130 if (ForDefinition &&
4137 while (!ForDefinition || !Primary->isMemberSpecialization()) {
4138 auto *NewPrimary = Primary->getInstantiatedFromMemberTemplate();
4141 Primary = NewPrimary;
4152 = TemplateOrSpecialization
4153 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4154 return Info->getTemplate();
4161 return TemplateOrSpecialization
4168 = TemplateOrSpecialization
4169 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4170 return Info->TemplateArguments;
4178 = TemplateOrSpecialization
4179 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4180 return Info->TemplateArgumentsAsWritten;
4183 TemplateOrSpecialization
4184 .dyn_cast<DependentFunctionTemplateSpecializationInfo *>()) {
4185 return Info->TemplateArgumentsAsWritten;
4190void FunctionDecl::setFunctionTemplateSpecialization(
4196 assert((TemplateOrSpecialization.isNull() ||
4198 "Member function is already a specialization");
4200 "Must specify the type of function template specialization");
4201 assert((TemplateOrSpecialization.isNull() ||
4204 "Member specialization must be an explicit specialization");
4207 C,
this, Template, TSK, TemplateArgs, TemplateArgsAsWritten,
4208 PointOfInstantiation,
4210 TemplateOrSpecialization = Info;
4217 assert(TemplateOrSpecialization.isNull());
4221 TemplateOrSpecialization = Info;
4226 return TemplateOrSpecialization
4234 const auto *TArgsWritten =
4237 totalSizeToAlloc<FunctionTemplateDecl *>(Candidates.
size())))
4241DependentFunctionTemplateSpecializationInfo::
4242 DependentFunctionTemplateSpecializationInfo(
4245 : NumCandidates(Candidates.size()),
4246 TemplateArgumentsAsWritten(TemplateArgsWritten) {
4247 std::transform(Candidates.
begin(), Candidates.
end(),
4248 getTrailingObjects<FunctionTemplateDecl *>(),
4250 return cast<FunctionTemplateDecl>(ND->getUnderlyingDecl());
4258 TemplateOrSpecialization
4259 .dyn_cast<FunctionTemplateSpecializationInfo *>())
4260 return FTSInfo->getTemplateSpecializationKind();
4264 return MSInfo->getTemplateSpecializationKind();
4268 if (TemplateOrSpecialization
4269 .is<DependentFunctionTemplateSpecializationInfo *>() &&
4301 TemplateOrSpecialization
4302 .dyn_cast<FunctionTemplateSpecializationInfo *>()) {
4303 if (
auto *MSInfo = FTSInfo->getMemberSpecializationInfo())
4304 return MSInfo->getTemplateSpecializationKind();
4305 return FTSInfo->getTemplateSpecializationKind();
4310 return MSInfo->getTemplateSpecializationKind();
4312 if (TemplateOrSpecialization
4313 .is<DependentFunctionTemplateSpecializationInfo *>() &&
4324 = TemplateOrSpecialization.dyn_cast<
4326 FTSInfo->setTemplateSpecializationKind(TSK);
4328 PointOfInstantiation.
isValid() &&
4329 FTSInfo->getPointOfInstantiation().isInvalid()) {
4330 FTSInfo->setPointOfInstantiation(PointOfInstantiation);
4332 L->InstantiationRequested(
this);
4336 MSInfo->setTemplateSpecializationKind(TSK);
4338 PointOfInstantiation.
isValid() &&
4339 MSInfo->getPointOfInstantiation().isInvalid()) {
4340 MSInfo->setPointOfInstantiation(PointOfInstantiation);
4342 L->InstantiationRequested(
this);
4345 llvm_unreachable(
"Function cannot have a template specialization kind");
4350 = TemplateOrSpecialization.dyn_cast<
4352 return FTSInfo->getPointOfInstantiation();
4355 return MSInfo->getPointOfInstantiation();
4376 if (FunTmpl->getTemplatedDecl()->hasBody(
Definition))
4395 case Builtin::BI__builtin_memset:
4396 case Builtin::BI__builtin___memset_chk:
4397 case Builtin::BImemset:
4398 return Builtin::BImemset;
4400 case Builtin::BI__builtin_memcpy:
4401 case Builtin::BI__builtin___memcpy_chk:
4402 case Builtin::BImemcpy:
4403 return Builtin::BImemcpy;
4405 case Builtin::BI__builtin_mempcpy:
4406 case Builtin::BI__builtin___mempcpy_chk:
4407 case Builtin::BImempcpy:
4408 return Builtin::BImempcpy;
4410 case Builtin::BI__builtin_memmove:
4411 case Builtin::BI__builtin___memmove_chk:
4412 case Builtin::BImemmove:
4413 return Builtin::BImemmove;
4415 case Builtin::BIstrlcpy:
4416 case Builtin::BI__builtin___strlcpy_chk:
4417 return Builtin::BIstrlcpy;
4419 case Builtin::BIstrlcat:
4420 case Builtin::BI__builtin___strlcat_chk:
4421 return Builtin::BIstrlcat;
4423 case Builtin::BI__builtin_memcmp:
4424 case Builtin::BImemcmp:
4425 return Builtin::BImemcmp;
4427 case Builtin::BI__builtin_bcmp:
4428 case Builtin::BIbcmp:
4429 return Builtin::BIbcmp;
4431 case Builtin::BI__builtin_strncpy:
4432 case Builtin::BI__builtin___strncpy_chk:
4433 case Builtin::BIstrncpy:
4434 return Builtin::BIstrncpy;
4436 case Builtin::BI__builtin_strncmp:
4437 case Builtin::BIstrncmp:
4438 return Builtin::BIstrncmp;
4440 case Builtin::BI__builtin_strncasecmp:
4441 case Builtin::BIstrncasecmp:
4442 return Builtin::BIstrncasecmp;
4444 case Builtin::BI__builtin_strncat:
4445 case Builtin::BI__builtin___strncat_chk:
4446 case Builtin::BIstrncat:
4447 return Builtin::BIstrncat;
4449 case Builtin::BI__builtin_strndup:
4450 case Builtin::BIstrndup:
4451 return Builtin::BIstrndup;
4453 case Builtin::BI__builtin_strlen:
4454 case Builtin::BIstrlen:
4455 return Builtin::BIstrlen;
4457 case Builtin::BI__builtin_bzero:
4458 case Builtin::BIbzero:
4459 return Builtin::BIbzero;
4461 case Builtin::BI__builtin_bcopy:
4462 case Builtin::BIbcopy:
4463 return Builtin::BIbcopy;
4465 case Builtin::BIfree:
4466 return Builtin::BIfree;
4470 if (FnInfo->
isStr(
"memset"))
4471 return Builtin::BImemset;
4472 if (FnInfo->
isStr(
"memcpy"))
4473 return Builtin::BImemcpy;
4474 if (FnInfo->
isStr(
"mempcpy"))
4475 return Builtin::BImempcpy;
4476 if (FnInfo->
isStr(
"memmove"))
4477 return Builtin::BImemmove;
4478 if (FnInfo->
isStr(
"memcmp"))
4479 return Builtin::BImemcmp;
4480 if (FnInfo->
isStr(
"bcmp"))
4481 return Builtin::BIbcmp;
4482 if (FnInfo->
isStr(
"strncpy"))
4483 return Builtin::BIstrncpy;
4484 if (FnInfo->
isStr(
"strncmp"))
4485 return Builtin::BIstrncmp;
4486 if (FnInfo->
isStr(
"strncasecmp"))
4487 return Builtin::BIstrncasecmp;
4488 if (FnInfo->
isStr(
"strncat"))
4489 return Builtin::BIstrncat;
4490 if (FnInfo->
isStr(
"strndup"))
4491 return Builtin::BIstrndup;
4492 if (FnInfo->
isStr(
"strlen"))
4493 return Builtin::BIstrlen;
4494 if (FnInfo->
isStr(
"bzero"))
4495 return Builtin::BIbzero;
4496 if (FnInfo->
isStr(
"bcopy"))
4497 return Builtin::BIbcopy;
4499 if (FnInfo->
isStr(
"free"))
4500 return Builtin::BIfree;
4508 assert(hasODRHash());
4517 setHasODRHash(
true);
4524 setHasODRHash(
true);
4538 return new (
C, DC)
FieldDecl(Decl::Field, DC, StartLoc, IdLoc,
Id,
T, TInfo,
4539 BW, Mutable, InitStyle);
4553 return Record->getDecl()->isAnonymousStructOrUnion();
4563 return cast_if_present<Expr>(
4565 : InitPtr.
get(
nullptr));
4597 if (!hasAttr<NoUniqueAddressAttr>())
4606 assert(
isInvalidDecl() &&
"valid field has incomplete type");
4612 const auto *CXXRD = cast<CXXRecordDecl>(RD);
4613 if (!CXXRD->isEmpty())
4623 return !llvm::any_of(CXXRD->fields(), [](
const FieldDecl *Field) {
4624 return Field->getType()->getAs<RecordType>();
4634 if (Canonical !=
this)
4637 if (CachedFieldIndex)
return CachedFieldIndex - 1;
4641 assert(RD &&
"requested index for field of struct with no definition");
4643 for (
auto *Field : RD->
fields()) {
4644 Field->getCanonicalDecl()->CachedFieldIndex = Index + 1;
4645 assert(Field->getCanonicalDecl()->CachedFieldIndex == Index + 1 &&
4646 "overflow in field numbering");
4650 assert(CachedFieldIndex &&
"failed to find field in parent");
4651 return CachedFieldIndex - 1;
4665 "capturing type in non-lambda or captured record.");
4666 assert(StorageKind == ISK_NoInit && !BitField &&
4667 "bit-field or field with default member initializer cannot capture "
4669 StorageKind = ISK_CapturedVLAType;
4693 "EnumDecl not matched with TagTypeKind::Enum");
4701 TagDeclBits.IsThisDeclarationADemotedDefinition =
false;
4717 TypedefNameDeclOrQualifier = TDD;
4728 if (
auto *
D = dyn_cast<CXXRecordDecl>(
this)) {
4729 struct CXXRecordDecl::DefinitionData *
Data =
4732 cast<CXXRecordDecl>(I)->DefinitionData =
Data;
4737 assert((!isa<CXXRecordDecl>(
this) ||
4739 "definition completed but not started");
4745 L->CompletedTagDefinition(
this);
4750 return const_cast<TagDecl *
>(
this);
4755 if (II->isOutOfDate()) {
4761 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(
this))
4762 return CXXRD->getDefinition();
4765 if (R->isCompleteDefinition())
4781 if (getExtInfo()->NumTemplParamLists == 0) {
4795 if (Name.isIdentifier() && !Name.getAsIdentifierInfo()) {
4800 Copy.SuppressScope =
true;
4805 Name.print(OS, Policy);
4810 assert(!TPLists.empty());
4825 bool Scoped,
bool ScopedUsingClassTag,
bool Fixed)
4827 assert(Scoped || !ScopedUsingClassTag);
4828 IntegerType =
nullptr;
4829 setNumPositiveBits(0);
4830 setNumNegativeBits(0);
4832 setScopedUsingClassTag(ScopedUsingClassTag);
4834 setHasODRHash(
false);
4838void EnumDecl::anchor() {}
4844 bool IsScopedUsingClassTag,
bool IsFixed) {
4846 IsScoped, IsScopedUsingClassTag, IsFixed);
4847 Enum->setMayHaveOutOfDateDef(
C.getLangOpts().Modules);
4848 C.getTypeDeclType(
Enum, PrevDecl);
4855 nullptr,
nullptr,
false,
false,
false);
4856 Enum->setMayHaveOutOfDateDef(
C.getLangOpts().Modules);
4862 return TI->getTypeLoc().getSourceRange();
4868 unsigned NumPositiveBits,
4869 unsigned NumNegativeBits) {
4873 PromotionType = NewPromotionType;
4874 setNumPositiveBits(NumPositiveBits);
4875 setNumNegativeBits(NumNegativeBits);
4880 if (
const auto *A = getAttr<EnumExtensibilityAttr>())
4881 return A->getExtensibility() == EnumExtensibilityAttr::Closed;
4886 return isClosed() && hasAttr<FlagEnumAttr>();
4890 return isClosed() && !hasAttr<FlagEnumAttr>();
4895 return MSI->getTemplateSpecializationKind();
4903 assert(MSI &&
"Not an instantiated member enumeration?");
4906 PointOfInstantiation.
isValid() &&
4922 "couldn't find pattern for enum instantiation");
4927 if (SpecializationInfo)
4935 assert(!SpecializationInfo &&
"Member enum is already a specialization");
4945 setHasODRHash(
true);
4956 Res.setEnd(TSI->getTypeLoc().getEndLoc());
4966 if (NumNegativeBits) {
4967 unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1);
4968 Max = llvm::APInt(Bitwidth, 1) << (NumBits - 1);
4971 Max = llvm::APInt(Bitwidth, 1) << NumPositiveBits;
4972 Min = llvm::APInt::getZero(Bitwidth);
4984 :
TagDecl(DK, TK,
C, DC, IdLoc,
Id, PrevDecl, StartLoc) {
4985 assert(
classof(
static_cast<Decl *
>(
this)) &&
"Invalid Kind!");
5007 StartLoc, IdLoc,
Id, PrevDecl);
5010 C.getTypeDeclType(R, PrevDecl);
5029 if (
auto RD = dyn_cast<CXXRecordDecl>(
this))
5030 return RD->isLambda();
5035 return hasAttr<CapturedRecordAttr>();
5047 for (
const FieldDecl *FD : Def->fields()) {
5059 LoadFieldsFromExternalStorage();
5063 return D->field_begin();
5091 return hasAttr<MSStructAttr>() ||
C.getLangOpts().MSBitfields == 1;
5100void RecordDecl::LoadFieldsFromExternalStorage()
const {
5115 for (
unsigned i=0, e=Decls.size(); i != e; ++i)
5116 assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i]));
5122 auto [ExternalFirst, ExternalLast] =
5125 ExternalLast->NextInContextAndBits.setPointer(
FirstDecl);
5134 (SanitizerKind::Address | SanitizerKind::KernelAddress);
5135 if (!EnabledAsanMask || !Context.
getLangOpts().SanitizeAddressFieldPadding)
5138 const auto *CXXRD = dyn_cast<CXXRecordDecl>(
this);
5140 int ReasonToReject = -1;
5141 if (!CXXRD || CXXRD->isExternCContext())
5143 else if (CXXRD->hasAttr<PackedAttr>())
5145 else if (CXXRD->isUnion())
5147 else if (CXXRD->isTriviallyCopyable())
5149 else if (CXXRD->hasTrivialDestructor())
5151 else if (CXXRD->isStandardLayout())
5161 if (ReasonToReject >= 0)
5164 diag::remark_sanitize_address_insert_extra_padding_rejected)
5169 diag::remark_sanitize_address_insert_extra_padding_accepted)
5172 return ReasonToReject < 0;
5176 for (
const auto *I :
fields()) {
5177 if (I->getIdentifier())
5180 if (
const auto *RT = I->getType()->getAs<
RecordType>())
5182 RT->getDecl()->findFirstNamedDataMember())
5183 return NamedDataMember;
5218 assert(!ParamInfo &&
"Already has param info!");
5221 if (!NewParamInfo.empty()) {
5222 NumParams = NewParamInfo.size();
5224 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
5229 bool CapturesCXXThis) {
5231 this->NumCaptures = Captures.size();
5233 if (Captures.empty()) {
5234 this->Captures =
nullptr;
5238 this->Captures = Captures.copy(Context).data();
5244 if (I.getVariable() == variable)
5258void TranslationUnitDecl::anchor() {}
5265 AnonymousNamespace =
D;
5268 Listener->AddedAnonymousNamespace(
this,
D);
5271void PragmaCommentDecl::anchor() {}
5279 new (
C, DC, additionalSizeToAlloc<char>(Arg.size() + 1))
5281 memcpy(PCD->getTrailingObjects<
char>(), Arg.data(), Arg.size());
5282 PCD->getTrailingObjects<
char>()[Arg.size()] =
'\0';
5289 return new (
C,
ID, additionalSizeToAlloc<char>(ArgSize + 1))
5293void PragmaDetectMismatchDecl::anchor() {}
5299 size_t ValueStart = Name.size() + 1;
5301 new (
C, DC, additionalSizeToAlloc<char>(ValueStart +
Value.size() + 1))
5303 memcpy(PDMD->getTrailingObjects<
char>(), Name.data(), Name.size());
5304 PDMD->getTrailingObjects<
char>()[Name.size()] =
'\0';
5305 memcpy(PDMD->getTrailingObjects<
char>() + ValueStart,
Value.data(),
5307 PDMD->getTrailingObjects<
char>()[ValueStart +
Value.size()] =
'\0';
5313 unsigned NameValueSize) {
5314 return new (
C,
ID, additionalSizeToAlloc<char>(NameValueSize + 1))
5318void ExternCContextDecl::anchor() {}
5325void LabelDecl::anchor() {}
5329 return new (
C, DC)
LabelDecl(DC, IdentL, II,
nullptr, IdentL);
5335 assert(GnuLabelL != IdentL &&
"Use this only for GNU local labels");
5336 return new (
C, DC)
LabelDecl(DC, IdentL, II,
nullptr, GnuLabelL);
5345char *Buffer =
new (
getASTContext(), 1)
char[Name.size() + 1];
5346 memcpy(Buffer, Name.data(), Name.size());
5347 Buffer[Name.size()] =
'\0';
5351void ValueDecl::anchor() {}
5355 return MostRecent->hasAttr<WeakAttr>() ||
5360 if (
auto *Var = llvm::dyn_cast<VarDecl>(
this))
5361 return Var->isInitCapture();
5365void ImplicitParamDecl::anchor() {}
5388 bool isInlineSpecified,
bool hasWrittenPrototype,
5390 Expr *TrailingRequiresClause) {
5412CapturedDecl::CapturedDecl(
DeclContext *DC,
unsigned NumParams)
5414 NumParams(NumParams), ContextParam(0), BodyAndNothrow(nullptr,
false) {}
5417 unsigned NumParams) {
5418 return new (
C, DC, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
5423 unsigned NumParams) {
5424 return new (
C,
ID, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
5444 Expr *
E,
const llvm::APSInt &
V) {
5451 QualType(),
nullptr, llvm::APSInt());
5454void IndirectFieldDecl::anchor() {}
5460 :
ValueDecl(IndirectField, DC, L, N,
T), Chaining(CH.data()),
5461 ChainingSize(CH.size()) {
5464 if (
C.getLangOpts().CPlusPlus)
5485 End =
Init->getEndLoc();
5489void TypeDecl::anchor() {}
5498void TypedefNameDecl::anchor() {}
5503 auto *ThisTypedef =
this;
5504 if (AnyRedecl && OwningTypedef) {
5508 if (OwningTypedef == ThisTypedef)
5509 return TT->getDecl();
5515bool TypedefNameDecl::isTransparentTagSlow()
const {
5516 auto determineIsTransparent = [&]() {
5518 if (
auto *TD = TT->getDecl()) {
5519 if (TD->getName() !=
getName())
5526 return SM.getSpellingLoc(TTLoc) ==
SM.getSpellingLoc(TDLoc);
5532 bool isTransparent = determineIsTransparent();
5533 MaybeModedTInfo.setInt((isTransparent << 1) | 1);
5534 return isTransparent;
5560 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
5568 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
5572void FileScopeAsmDecl::anchor() {}
5587void TopLevelStmtDecl::anchor() {}
5590 assert(
C.getLangOpts().IncrementalExtensions &&
5591 "Must be used only in incremental mode");
5615void EmptyDecl::anchor() {}
5625HLSLBufferDecl::HLSLBufferDecl(
DeclContext *DC,
bool CBuffer,
5630 IsCBuffer(CBuffer) {}
5678 :
Decl(
Import, DC, StartLoc), ImportedModule(Imported),
5679 NextLocalImportAndComplete(nullptr,
true) {
5681 auto *StoredLocs = getTrailingObjects<SourceLocation>();
5682 std::uninitialized_copy(IdentifierLocs.begin(), IdentifierLocs.end(),
5688 :
Decl(
Import, DC, StartLoc), ImportedModule(Imported),
5689 NextLocalImportAndComplete(nullptr,
false) {
5690 *getTrailingObjects<SourceLocation>() = EndLoc;
5697 additionalSizeToAlloc<SourceLocation>(IdentifierLocs.size()))
5698 ImportDecl(DC, StartLoc, Imported, IdentifierLocs);
5705 ImportDecl *Import =
new (
C, DC, additionalSizeToAlloc<SourceLocation>(1))
5707 Import->setImplicit();
5712 unsigned NumLocations) {
5713 return new (
C,
ID, additionalSizeToAlloc<SourceLocation>(NumLocations))
5718 if (!isImportComplete())
5719 return std::nullopt;
5721 const auto *StoredLocs = getTrailingObjects<SourceLocation>();
5727 if (!isImportComplete())
5737void ExportDecl::anchor() {}
5749 bool IncludeLocallyStreaming) {
5750 if (IncludeLocallyStreaming)
5751 if (FD->
hasAttr<ArmLocallyStreamingAttr>())
5756 if (FPT->getAArch64SMEAttributes() &
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines enum values for all the target-independent builtin functions.
enum clang::sema::@1651::IndirectLocalPathEntry::EntryKind Kind
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.
static bool isFirstInExternCContext(T *D)
static bool isRedeclarableImpl(Redeclarable< T > *)
static bool isDeclExternC(const T &D)
static bool hasExplicitVisibilityAlready(LVComputationKind computation)
Does this computation kind permit us to consider additional visibility settings from attributes and t...
static bool RedeclForcesDefC99(const FunctionDecl *Redecl)
static bool isExportedFromModuleInterfaceUnit(const NamedDecl *D)
static bool isRedeclarable(Decl::Kind K)
static bool redeclForcesDefMSVC(const FunctionDecl *Redecl)
static bool usesTypeVisibility(const NamedDecl *D)
Is the given declaration a "type" or a "value" for the purposes of visibility computation?
static std::optional< Visibility > getVisibilityOf(const NamedDecl *D, NamedDecl::ExplicitVisibilityKind kind)
Return the explicit visibility of the given declaration.
static bool isDeclaredInModuleInterfaceOrPartition(const NamedDecl *D)
static LanguageLinkage getDeclLanguageLinkage(const T &D)
static LVComputationKind withExplicitVisibilityAlready(LVComputationKind Kind)
Given an LVComputationKind, return one of the same type/value sort that records that it already has e...
static std::enable_if_t<!std::is_base_of_v< RedeclarableTemplateDecl, T >, bool > isExplicitMemberSpecialization(const T *D)
Does the given declaration have member specialization information, and if so, is it an explicit speci...
static unsigned getNumModuleIdentifiers(Module *Mod)
Retrieve the number of module identifiers needed to name the given module.
static bool isSingleLineLanguageLinkage(const Decl &D)
static bool useInlineVisibilityHidden(const NamedDecl *D)
static bool shouldConsiderTemplateVisibility(const FunctionDecl *fn, const FunctionTemplateSpecializationInfo *specInfo)
static bool hasDirectVisibilityAttribute(const NamedDecl *D, LVComputationKind computation)
Does the given declaration have a direct visibility attribute that would match the given rules?
static DeclT * getDefinitionOrSelf(DeclT *D)
static Visibility getVisibilityFromAttr(const T *attr)
Given a visibility attribute, return the explicit visibility associated with it.
static const Decl * getOutermostFuncOrBlockContext(const Decl *D)
static bool typeIsPostfix(QualType QT)
static LinkageInfo getExternalLinkageFor(const NamedDecl *D)
static StorageClass getStorageClass(const Decl *D)
static std::optional< Visibility > getExplicitVisibilityAux(const NamedDecl *ND, NamedDecl::ExplicitVisibilityKind kind, bool IsMostRecent)
static SourceLocation getTemplateOrInnerLocStart(const DeclT *decl)
static bool isNamed(const NamedDecl *ND, const char(&Str)[Len])
static std::optional< Visibility > getExplicitVisibility(const NamedDecl *D, LVComputationKind kind)
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
Defines the clang::Module class, which describes a module in the source code.
This file contains the declaration of the ODRHash class, which calculates a hash based on AST nodes,...
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
static std::string getName(const CallEvent &Call)
Defines the clang::SanitizerKind enum.
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Defines the TargetCXXABI class, which abstracts details of the C++ ABI that we're targeting.
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
static const TypeInfo & getInfo(unsigned id)
Defines the clang::Visibility enumeration and various utility functions.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
bool needsCleanup() const
Returns whether the object performed allocations.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
SourceManager & getSourceManager()
const ConstantArrayType * getAsConstantArrayType(QualType T) const
unsigned getIntWidth(QualType T) const
TemplateOrSpecializationInfo getTemplateOrSpecializationInfo(const VarDecl *Var)
void setTemplateOrSpecializationInfo(VarDecl *Inst, TemplateOrSpecializationInfo TSI)
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
ASTMutationListener * getASTMutationListener() const
Retrieve a pointer to the AST mutation listener associated with this AST context, if any.
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
void Deallocate(void *Ptr) const
Builtin::Context & BuiltinInfo
const LangOptions & getLangOpts() const
void setParameterIndex(const ParmVarDecl *D, unsigned index)
Used by ParmVarDecl to store on the side the index of the parameter when it exceeds the size of the n...
Decl * getPrimaryMergedDecl(Decl *D)
const NoSanitizeList & getNoSanitizeList() const
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
const clang::PrintingPolicy & getPrintingPolicy() const
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
void * Allocate(size_t Size, unsigned Align=8) const
void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Note that the static data member Inst is an instantiation of the static data member template Tmpl of ...
DiagnosticsEngine & getDiagnostics() const
const TargetInfo & getTargetInfo() const
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void addDestruction(T *Ptr) const
If T isn't trivially destructible, calls AddDeallocation to register it for destruction.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
unsigned getParameterIndex(const ParmVarDecl *D) const
Used by ParmVarDecl to retrieve on the side the index of the parameter when it exceeds the size of th...
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
CharUnits getSize() const
getSize - Get the record size in characters.
unsigned getFieldCount() const
getFieldCount - Get the number of fields in the layout.
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
BlockDecl(DeclContext *DC, SourceLocation CaretLoc)
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
void setDoesNotEscape(bool B=true)
void setCapturesCXXThis(bool B=true)
void setCanAvoidCopyToHeap(bool B=true)
void setIsConversionFromLambda(bool val=true)
void setBlockMissingReturnType(bool val=true)
ArrayRef< Capture > captures() const
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
static BlockDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setIsVariadic(bool value)
bool capturesVariable(const VarDecl *var) const
void setCaptures(ASTContext &Context, ArrayRef< Capture > Captures, bool CapturesCXXThis)
static BlockDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc",...
Represents a C++ struct/union/class.
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
Represents the body of a CapturedStmt, and serves as its DeclContext.
static CapturedDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumParams)
void setNothrow(bool Nothrow=true)
static CapturedDecl * Create(ASTContext &C, DeclContext *DC, unsigned NumParams)
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
CharUnits - This is an opaque type for sizes expressed in character units.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Declaration of a class template.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
Represents a class template specialization, which refers to a class template with a given set of temp...
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
bool isExplicitSpecialization() const
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration,...
bool isZeroSize() const
Return true if the size is zero.
A POD class for pairing a NamedDecl* with an access specifier.
decl_iterator - Iterates through the declarations stored within this context.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
FunctionDeclBitfields FunctionDeclBits
bool isFileContext() const
static std::pair< Decl *, Decl * > BuildDeclChain(ArrayRef< Decl * > Decls, bool FieldsAlreadyLoaded)
Build up a chain of declarations.
TagDeclBitfields TagDeclBits
bool isExternCXXContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
RecordDeclBitfields RecordDeclBits
Decl * FirstDecl
FirstDecl - The first declaration stored within this declaration context.
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Decl * LastDecl
LastDecl - The last declaration stored within this declaration context.
bool isInlineNamespace() const
bool isFunctionOrMethod() const
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Decl::Kind getDeclKind() const
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
bool isInStdNamespace() const
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isInNamedModule() const
Whether this declaration comes from a named module.
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
ModuleOwnershipKind getModuleOwnershipKind() const
Get the kind of module ownership for this declaration.
ASTMutationListener * getASTMutationListener() const
bool hasCachedLinkage() const
Kind
Lists the kind of concrete classes of Decl.
@ FOK_None
Not a friend object.
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
llvm::PointerIntPair< Decl *, 3, ModuleOwnershipKind > NextInContextAndBits
The next declaration within the same lexical DeclContext.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Linkage getCachedLinkage() const
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
bool isInvalidDecl() const
bool hasDefiningAttr() const
Return true if this declaration has an attribute which acts as definition of the entity,...
SourceLocation getLocation() const
IdentifierNamespace
IdentifierNamespace - The different namespaces in which declarations may appear.
@ IDNS_Tag
Tags, declared with 'struct foo;' and referenced with 'struct foo'.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
void setLocation(SourceLocation L)
DeclContext * getDeclContext()
bool isInAnonymousNamespace() const
void setCachedLinkage(Linkage L) const
void updateOutOfDate(IdentifierInfo &II) const
Update a potentially out-of-date declaration.
Module * getOwningModuleForLinkage() const
Get the module that owns this declaration for linkage purposes.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
@ VisibleWhenImported
This declaration has an owning module, and is visible when that module is imported.
@ Unowned
This declaration is not owned by a module.
@ ReachableWhenImported
This declaration has an owning module, and is visible to lookups that occurs within that module.
@ ModulePrivate
This declaration has an owning module, but is only visible to lookups that occur within that module.
@ Visible
This declaration has an owning module, but is globally visible (typically because its owning module i...
const LangOptions & getLangOpts() const LLVM_READONLY
Helper to get the language options from the ASTContext.
The name of a declaration.
void print(raw_ostream &OS, const PrintingPolicy &Policy) const
const IdentifierInfo * getCXXLiteralIdentifier() const
If this name is the name of a literal operator, retrieve the identifier associated with it.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
Represents a ValueDecl that came out of a declarator.
SourceLocation getTypeSpecEndLoc() const
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
SourceLocation getOuterLocStart() const
Return start of source range taking into account any outer template declarations.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
void setTrailingRequiresClause(Expr *TrailingRequiresClause)
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
TypeSourceInfo * getTypeSourceInfo() const
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Provides information about a dependent function-template specialization declaration.
static DependentFunctionTemplateSpecializationInfo * Create(ASTContext &Context, const UnresolvedSetImpl &Candidates, const TemplateArgumentListInfo *TemplateArgs)
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Represents an empty-declaration.
static EmptyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
static EmptyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
An instance of this object exists for each enum constant that is defined.
EnumConstantDecl(const ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E, const llvm::APSInt &V)
static EnumConstantDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
void setInitVal(const ASTContext &C, const llvm::APSInt &V)
static EnumConstantDecl * Create(ASTContext &C, EnumDecl *DC, SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E, const llvm::APSInt &V)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For an enumeration member that was instantiated from a member enumeration of a templated class,...
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists,...
static EnumDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
bool isClosedFlag() const
Returns true if this enum is annotated with flag_enum and isn't annotated with enum_extensibility(ope...
SourceRange getIntegerTypeRange() const LLVM_READONLY
Retrieve the source range that covers the underlying type if specified.
SourceRange getSourceRange() const override LLVM_READONLY
Overrides to provide correct range when there's an enum-base specifier with forward declarations.
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this enumeration is a member of a specialization of a templated class, determine what kind of temp...
bool isClosed() const
Returns true if this enum is either annotated with enum_extensibility(closed) or isn't annotated with...
EnumDecl * getTemplateInstantiationPattern() const
Retrieve the enum definition from which this enumeration could be instantiated, if it is an instantia...
bool isClosedNonFlag() const
Returns true if this enum is annotated with neither flag_enum nor enum_extensibility(open).
void getValueRange(llvm::APInt &Max, llvm::APInt &Min) const
Calculates the [Min,Max) values the enum can store based on the NumPositiveBits and NumNegativeBits.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
Represents a standard C++ module export declaration.
static ExportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExportLoc)
static ExportDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
This represents one expression.
bool isValueDependent() const
Determines whether the value of this expression depends on.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Declaration context for names declared as extern "C" in C++.
static ExternCContextDecl * Create(const ASTContext &C, TranslationUnitDecl *TU)
RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing.
Abstract interface for external sources of AST nodes.
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.
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
bool isBitField() const
Determines whether this field is a bitfield.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isZeroLengthBitField(const ASTContext &Ctx) const
Is this a zero-length bit-field? Such bit-fields aren't really bit-fields at all and instead act as a...
static FieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
unsigned getBitWidthValue(const ASTContext &Ctx) const
Computes the bit width of this field, if this is a bit field.
void setInClassInitializer(Expr *NewInit)
Set the C++11 in-class initializer for this member.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
bool isZeroSize(const ASTContext &Ctx) const
Determine if this field is a subobject of zero size, that is, either a zero-length bit-field or a fie...
InitAndBitWidthStorage * InitAndBitWidth
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
static bool classofKind(Kind K)
bool isUnnamedBitField() const
Determines whether this is an unnamed bitfield.
Expr * getBitWidth() const
Returns the expression that represents the bit width, if this field is a bit field.
void printName(raw_ostream &OS, const PrintingPolicy &Policy) const override
Pretty-print the unqualified name of this declaration.
bool isPotentiallyOverlapping() const
Determine if this field is of potentially-overlapping class type, that is, subobject with the [[no_un...
void setCapturedVLAType(const VariableArrayType *VLAType)
Set the captured variable length array type for this field.
const VariableArrayType * CapturedVLAType
static FileScopeAsmDecl * Create(ASTContext &C, DeclContext *DC, StringLiteral *Str, SourceLocation AsmLoc, SourceLocation RParenLoc)
static FileScopeAsmDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Stashed information about a defaulted/deleted function body.
static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)
void setDeletedMessage(StringLiteral *Message)
Represents a function declaration or definition.
unsigned getMemoryFunctionKind() const
Identify a memory copying or setting function.
bool isTargetClonesMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-clones functional...
bool isMultiVersion() const
True if this function is considered a multiversioned function.
const ParmVarDecl * getParamDecl(unsigned i) const
bool hasTrivialBody() const
Returns whether the function has a trivial body that does not require any specific codegen.
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
void setPreviousDeclaration(FunctionDecl *PrevDecl)
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
void setIsPureVirtual(bool P=true)
bool isImmediateFunction() const
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
SourceLocation getEllipsisLoc() const
Returns the location of the ellipsis of a variadic function.
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
static FunctionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
SourceLocation getPointOfInstantiation() const
Retrieve the (first) point of instantiation of a function template specialization or a member of a cl...
bool isMemberLikeConstrainedFriend() const
Determine whether a function is a friend function that cannot be redeclared outside of its class,...
bool hasCXXExplicitFunctionObjectParameter() const
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
bool UsesFPIntrin() const
Determine whether the function was declared in source context that requires constrained FP intrinsics...
void setHasWrittenPrototype(bool P=true)
State that this function has a written prototype.
bool isNoReturn() const
Determines whether this function is known to be 'noreturn', through an attribute on its declaration o...
ArrayRef< ParmVarDecl * > parameters() const
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
bool isMSExternInline() const
The combination of the extern and inline keywords under MSVC forces the function to be required.
unsigned getMinRequiredExplicitArguments() const
Returns the minimum number of non-object arguments needed to call this function.
bool BodyContainsImmediateEscalatingExpressions() const
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
bool hasWrittenPrototype() const
Whether this function has a written prototype.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization,...
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
FunctionTypeLoc getFunctionTypeLoc() const
Find the source location information for how the type of this function was written.
bool isVariadic() const
Whether this function is variadic.
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
bool isConstexprSpecified() const
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
SourceRange getExceptionSpecSourceRange() const
Attempt to compute an informative source range covering the function exception specification,...
bool hasBody() const override
Returns true if this Decl represents a declaration for a body of code, such as a function or method d...
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
unsigned getODRHash()
Returns ODRHash of the function.
TemplateSpecializationKind getTemplateSpecializationKindForInstantiation() const
Determine the kind of template specialization this function represents for the purpose of template in...
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
unsigned getNumNonObjectParams() const
TemplatedKind
The kind of templated function a FunctionDecl can be.
@ TK_MemberSpecialization
@ TK_DependentNonTemplate
@ TK_FunctionTemplateSpecialization
@ TK_DependentFunctionTemplateSpecialization
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function.
bool isInlineBuiltinDeclaration() const
Determine if this function provides an inline implementation of a builtin.
bool FriendConstraintRefersToEnclosingTemplate() const
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
void setInstantiatedFromDecl(FunctionDecl *FD)
Specify that this function declaration was instantiated from a FunctionDecl FD.
bool isDeletedAsWritten() const
bool isReservedGlobalPlacementOperator() const
Determines whether this operator new or delete is one of the reserved global placement operators: voi...
void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo *TemplateArgs)
Specifies that this function declaration is actually a dependent function template specialization.
bool isInExternCContext() const
Determines whether this function's context is, or is nested within, a C++ extern "C" linkage spec.
FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass S, bool UsesFPIntrin, bool isInlineSpecified, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
bool isImplicitlyInstantiable() const
Determines whether this function is a function template specialization or a member of a class templat...
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
LazyDeclStmtPtr Body
The body of the function.
bool isImmediateEscalating() const
DefaultedOrDeletedFunctionInfo * DefaultedOrDeletedInfo
Information about a future defaulted function definition.
bool isInExternCXXContext() const
Determines whether this function's context is, or is nested within, a C++ extern "C++" linkage spec.
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
bool isTargetVersionMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-version functiona...
bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
bool isThisDeclarationInstantiatedFromAFriendDefinition() const
Determine whether this specific declaration of the function is a friend declaration that was instanti...
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
bool isDefaulted() const
Whether this function is defaulted.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
FunctionDecl * getInstantiatedFromDecl() const
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Determine what kind of template instantiation this function represents.
const IdentifierInfo * getLiteralIdentifier() const
getLiteralIdentifier - The literal suffix identifier this function represents, if any.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
bool doesDeclarationForceExternallyVisibleDefinition() const
For a function declaration in C or C++, determine whether this declaration causes the definition to b...
bool isTargetMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target functionality.
bool isGlobal() const
Determines whether this is a global function.
bool hasOneParamOrDefaultArgs() const
Determine whether this function has a single parameter, or multiple parameters where all but the firs...
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
bool isTargetMultiVersionDefault() const
True if this function is the default version of a multiversioned dispatch function as a part of the t...
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
bool isInlineDefinitionExternallyVisible() const
For an inline function definition in C, or for a gnu_inline function in C++, determine whether the de...
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
DeclarationNameInfo getNameInfo() const
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
SourceRange getParametersSourceRange() const
Attempt to compute an informative source range covering the function parameters, including the ellips...
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
MultiVersionKind getMultiVersionKind() const
Gets the kind of multiversioning attribute this declaration has.
DefaultedOrDeletedFunctionInfo * getDefalutedOrDeletedInfo() const
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
Appends a human-readable name for this declaration into the given stream.
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
const ASTTemplateArgumentListInfo * getTemplateSpecializationArgsAsWritten() const
Retrieve the template argument list as written in the sources, if any.
Represents a prototype with parameter type info, e.g.
unsigned getNumParams() const
bool isVariadic() const
Whether this function prototype is variadic.
Declaration of a template function.
void addSpecialization(FunctionTemplateSpecializationInfo *Info, void *InsertPos)
Add a specialization of this function template.
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
Provides information about a function template specialization, which is a FunctionDecl that has been ...
TemplateArgumentList * TemplateArguments
The template arguments used to produce the function template specialization from the function templat...
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
static FunctionTemplateSpecializationInfo * Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template, TemplateSpecializationKind TSK, TemplateArgumentList *TemplateArgs, const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI, MemberSpecializationInfo *MSInfo)
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration,...
Wrapper for source info for functions.
SourceRange getExceptionSpecRange() const
TypeLoc getReturnLoc() const
FunctionType - C99 6.7.5.3 - Function Declarators.
@ SME_PStateSMEnabledMask
HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.
static HLSLBufferDecl * Create(ASTContext &C, DeclContext *LexicalParent, bool CBuffer, SourceLocation KwLoc, IdentifierInfo *ID, SourceLocation IDLoc, SourceLocation LBrace)
static HLSLBufferDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
One of these records is kept for each identifier that is lexed.
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine whether this is a name reserved for the implementation (C99 7.1.3, C++ [lib....
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
static ImplicitParamDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Describes a module import declaration, which makes the contents of the named module visible in the cu...
static ImportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, ArrayRef< SourceLocation > IdentifierLocs)
Create a new module import declaration.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
static ImportDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumLocations)
Create a new, deserialized module import declaration.
ArrayRef< SourceLocation > getIdentifierLocs() const
Retrieves the locations of each of the identifiers that make up the complete module name in the impor...
Module * getImportedModule() const
Retrieve the module that was imported by the import declaration.
static ImportDecl * CreateImplicit(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, SourceLocation EndLoc)
Create a new module import declaration for an implicitly-generated import.
Represents a field injected from an anonymous union/struct into the parent scope.
static bool classofKind(Kind K)
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, const IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl * > CH)
static IndirectFieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Represents the declaration of a label.
void setMSAsmLabel(StringRef Name)
static LabelDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II)
static LabelDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
SanitizerSet Sanitize
Set of enabled sanitizers.
LinkageInfo getTypeLinkageAndVisibility(const Type *T)
LinkageInfo computeLVForDecl(const NamedDecl *D, LVComputationKind computation, bool IgnoreVarTypeLinkage=false)
LinkageInfo getLVForDecl(const NamedDecl *D, LVComputationKind computation)
getLVForDecl - Get the linkage and visibility for the given declaration.
LinkageInfo getDeclLinkageAndVisibility(const NamedDecl *D)
Visibility getVisibility() const
static LinkageInfo external()
static LinkageInfo none()
void setLinkage(Linkage L)
void mergeExternalVisibility(Linkage L)
void mergeMaybeWithVisibility(LinkageInfo other, bool withVis)
Merge linkage and conditionally merge visibility.
Linkage getLinkage() const
static LinkageInfo internal()
static LinkageInfo visible_none()
static LinkageInfo uniqueExternal()
void mergeVisibility(Visibility newVis, bool newExplicit)
Merge in the visibility 'newVis'.
bool isVisibilityExplicit() const
void merge(LinkageInfo other)
Merge both linkage and visibility.
Provides information a specialization of a member of a class template, which may be a member function...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
NamedDecl * getInstantiatedFrom() const
Retrieve the member declaration from which this member was instantiated.
Describes a module or submodule.
Module * Parent
The parent of this module.
ModuleKind Kind
The kind of this module.
@ ModuleImplementationUnit
This is a C++20 module implementation unit.
@ ModuleMapModule
This is a module that was defined by a module map and built out of header files.
@ ImplicitGlobalModuleFragment
This is an implicit fragment of the global module which contains only language linkage declarations (...
@ ModulePartitionInterface
This is a C++20 module partition interface.
@ ModuleInterfaceUnit
This is a C++20 module interface unit.
@ ModuleHeaderUnit
This is a C++20 header unit.
@ ModulePartitionImplementation
This is a C++20 module partition implementation.
@ PrivateModuleFragment
This is the private module fragment within some C++ module.
@ ExplicitGlobalModuleFragment
This is the explicit Global Module Fragment of a modular TU.
This represents a decl that may have a name.
ExplicitVisibilityKind
Kinds of explicit visibility.
@ VisibilityForValue
Do an LV computation for, ultimately, a non-type declaration.
@ VisibilityForType
Do an LV computation for, ultimately, a type.
Linkage getLinkageInternal() const
Determine what kind of linkage this entity has.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
LinkageInfo getLinkageAndVisibility() const
Determines the linkage and visibility of this entity.
bool isLinkageValid() const
True if the computed linkage is valid.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
bool isPlaceholderVar(const LangOptions &LangOpts) const
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
std::string getQualifiedNameAsString() const
std::optional< Visibility > getExplicitVisibility(ExplicitVisibilityKind kind) const
If visibility was explicitly specified for this declaration, return that visibility.
NamedDecl * getMostRecentDecl()
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given stream.
bool declarationReplaces(const NamedDecl *OldD, bool IsKnownNewer=true) const
Determine whether this declaration, if known to be well-formed within its context,...
ObjCStringFormatFamily getObjCFStringFormattingFamily() const
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
void printQualifiedName(raw_ostream &OS) const
Returns a human-readable qualified name for this declaration, like A::B::i, for i being member of nam...
virtual void printName(raw_ostream &OS, const PrintingPolicy &Policy) const
Pretty-print the unqualified name of this declaration.
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
bool hasLinkage() const
Determine whether this declaration has linkage.
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine if the declaration obeys the reserved identifier rules of the given language.
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
void printNestedNameSpecifier(raw_ostream &OS) const
Print only the nested name specifier part of a fully-qualified name, including the '::' at the end.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
bool containsType(SanitizerMask Mask, StringRef MangledTypeName, StringRef Category=StringRef()) const
bool containsLocation(SanitizerMask Mask, SourceLocation Loc, StringRef Category=StringRef()) const
void AddEnumDecl(const EnumDecl *Enum)
void AddFunctionDecl(const FunctionDecl *Function, bool SkipBody=false)
void AddRecordDecl(const RecordDecl *Record)
Represents a parameter to a function.
void setDefaultArg(Expr *defarg)
static ParmVarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
void setUninstantiatedDefaultArg(Expr *arg)
bool hasUninstantiatedDefaultArg() const
bool isDestroyedInCallee() const
Determines whether this parameter is destroyed in the callee function.
bool hasInheritedDefaultArg() const
bool isExplicitObjectParameter() const
QualType getOriginalType() const
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Expr * getUninstantiatedDefaultArg()
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Represents a #pragma detect_mismatch line.
static PragmaDetectMismatchDecl * Create(const ASTContext &C, TranslationUnitDecl *DC, SourceLocation Loc, StringRef Name, StringRef Value)
static PragmaDetectMismatchDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NameValueSize)
void print(raw_ostream &OS) const override
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
const Type * getTypePtrOrNull() const
Represents a struct/union/class.
bool hasLoadedFieldsFromExternalStorage() const
unsigned getODRHash()
Get precomputed ODRHash or add a new one.
bool isLambda() const
Determine whether this record is a class describing a lambda function object.
bool isMsStruct(const ASTContext &C) const
Get whether or not this is an ms_struct which can be turned on with an attribute, pragma,...
void setAnonymousStructOrUnion(bool Anon)
const FieldDecl * findFirstNamedDataMember() const
Finds the first data member which has a name.
void setArgPassingRestrictions(RecordArgPassingKind Kind)
void setNonTrivialToPrimitiveCopy(bool V)
bool isCapturedRecord() const
Determine whether this record is a record for captured variables in CapturedStmt construct.
void setHasNonTrivialToPrimitiveCopyCUnion(bool V)
field_range fields() const
void setHasNonTrivialToPrimitiveDestructCUnion(bool V)
void setHasFlexibleArrayMember(bool V)
void setParamDestroyedInCallee(bool V)
void setNonTrivialToPrimitiveDestroy(bool V)
void setHasObjectMember(bool val)
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
void setHasVolatileMember(bool val)
void setHasNonTrivialToPrimitiveDefaultInitializeCUnion(bool V)
void reorderDecls(const SmallVectorImpl< Decl * > &Decls)
void setIsRandomized(bool V)
static RecordDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)
bool mayInsertExtraPadding(bool EmitRemark=false) const
Whether we are allowed to insert extra padding between fields.
static bool classof(const Decl *D)
bool isOrContainsUnion() const
Returns whether this record is a union, or contains (at any nesting level) a union member.
virtual void completeDefinition()
Note that the definition of this type is now complete.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
void setCapturedRecord()
Mark the record as a record for captured variables in CapturedStmt construct.
specific_decl_iterator< FieldDecl > field_iterator
void setNonTrivialToPrimitiveDefaultInitialize(bool V)
void setHasLoadedFieldsFromExternalStorage(bool val) const
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Declaration of a redeclarable template.
Provides common interface for the Decls that can be redeclared.
VarDecl * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
VarDecl * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
void setPreviousDecl(FunctionDecl *PrevDecl)
Set the previous declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
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
This class handles loading and caching of source files into memory.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
Represents the declaration of a struct/union/class/enum.
void setTagKind(TagKind TK)
void setCompleteDefinitionRequired(bool V=true)
True if this complete decl is required to be complete for some existing use.
SourceRange getBraceRange() const
TagDecl * getDefinition() const
Returns the TagDecl that actually defines this struct/union/class/enum.
void setEmbeddedInDeclarator(bool isInDeclarator)
True if this tag declaration is "embedded" (i.e., defined or declared for the very first time) in the...
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
void setMayHaveOutOfDateDef(bool V=true)
Indicates whether it is possible for declarations of this kind to have an out-of-date definition.
TypedefNameDecl * getTypedefNameForAnonDecl() const
void startDefinition()
Starts the definition of this tag declaration.
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
bool mayHaveOutOfDateDef() const
Indicates whether it is possible for declarations of this kind to have an out-of-date definition.
SourceLocation getOuterLocStart() const
Return SourceLocation representing start of source range taking into account any outer template decla...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
void setBeingDefined(bool V=true)
True if this decl is currently being defined.
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
void completeDefinition()
Completes the definition of this tag declaration.
void printName(raw_ostream &OS, const PrintingPolicy &Policy) const override
Pretty-print the unqualified name of this declaration.
void setFreeStanding(bool isFreeStanding=true)
True if this tag is free standing, e.g. "struct foo;".
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl, SourceLocation StartL)
void setCompleteDefinition(bool V=true)
True if this decl has its body fully specified.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
A convenient class for passing around template argument information.
A template argument list.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Represents a template argument.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
The base class of all kinds of template declarations (e.g., class, function, etc.).
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Stores a list of template parameters for a TemplateDecl and its derived classes.
A declaration that models statements at global scope.
static TopLevelStmtDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
static TopLevelStmtDecl * Create(ASTContext &C, Stmt *Statement)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
The top declaration context.
static TranslationUnitDecl * Create(ASTContext &C)
ASTContext & getASTContext() const
void setAnonymousNamespace(NamespaceDecl *D)
Represents the declaration of a typedef-name via a C++11 alias-declaration.
static TypeAliasDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Represents a declaration of a type.
const Type * getTypeForDecl() const
SourceLocation getBeginLoc() const LLVM_READONLY
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
TypeLoc IgnoreParens() const
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceLocation getEndLoc() const
Get the end source location.
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isLinkageValid() const
True if the computed linkage is valid.
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isFunctionType() const
Linkage getLinkage() const
Determine the linkage of this type.
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
static TypedefDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Base class for declarations which introduce a typedef-name.
TypeSourceInfo * getTypeSourceInfo() const
QualType getUnderlyingType() const
TypedefNameDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this typedef-name.
TagDecl * getAnonDeclWithTypedefName(bool AnyRedecl=false) const
Retrieves the tag declaration for which this is the typedef name for linkage purposes,...
A set of unresolved declarations.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Represents a variable declaration or definition.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Stmt ** getInitAddress()
Retrieve the address of the initializer expression.
DefinitionKind isThisDeclarationADefinition() const
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
void setInstantiationOfStaticDataMember(VarDecl *VD, TemplateSpecializationKind TSK)
Specify that this variable is an instantiation of the static data member VD.
TLSKind getTLSKind() const
bool hasICEInitializer(const ASTContext &Context) const
Determine whether the initializer of this variable is an integer constant expression.
ParmVarDeclBitfields ParmVarDeclBits
DefinitionKind hasDefinition() const
static const char * getStorageClassSpecifierString(StorageClass SC)
Return the string used to specify the storage class SC.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member.
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool hasFlexibleArrayInit(const ASTContext &Ctx) const
Whether this variable has a flexible array member initialized with one or more elements.
bool isNoDestroy(const ASTContext &) const
Is destruction of this variable entirely suppressed? If so, the variable need not have a usable destr...
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
void setStorageClass(StorageClass SC)
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
bool isStaticDataMember() const
Determines whether this is a static data member.
static VarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
VarDecl * getTemplateInstantiationPattern() const
Retrieve the variable declaration from which this variable could be instantiated, if it is an instant...
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
VarDeclBitfields VarDeclBits
CharUnits getFlexibleArrayInitChars(const ASTContext &Ctx) const
If hasFlexibleArrayInit is true, compute the number of additional bytes necessary to store those elem...
bool hasConstantInitialization() const
Determine whether this variable has constant initialization.
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
EvaluatedStmt * getEvaluatedStmt() const
bool mightBeUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value might be usable in a constant expression, according to the re...
EvaluatedStmt * ensureEvaluatedStmt() const
Convert the initializer for this declaration to the elaborated EvaluatedStmt form,...
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization,...
bool isFileVarDecl() const
Returns true for file scoped variable declaration.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
bool checkForConstantInitialization(SmallVectorImpl< PartialDiagnosticAt > &Notes) const
Evaluate the initializer of this variable to determine whether it's a constant initializer.
bool isInline() const
Whether this variable is (C++1z) inline.
const Expr * getInit() const
bool isNonEscapingByref() const
Indicates the capture is a __block variable that is never captured by an escaping block.
bool isInExternCContext() const
Determines whether this variable's context is, or is nested within, a C++ extern "C" linkage spec.
NonParmVarDeclBitfields NonParmVarDeclBits
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
InitType Init
The initializer for this variable or, for a ParmVarDecl, the C++ default argument.
APValue * getEvaluatedValue() const
Return the already-evaluated value of this variable's initializer, or NULL if the value is not yet kn...
VarDecl * getInitializingDeclaration()
Get the initializing declaration of this variable, if any.
TLSKind
Kinds of thread-local storage.
@ TLS_Static
TLS with a known-constant initializer.
@ TLS_Dynamic
TLS with a dynamic initializer.
@ TLS_None
Not a TLS variable.
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
@ TentativeDefinition
This declaration is a tentative definition.
@ DeclarationOnly
This declaration is only a declaration.
@ Definition
This declaration is definitely a definition.
void setDescribedVarTemplate(VarTemplateDecl *Template)
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass SC)
StorageDuration getStorageDuration() const
Get the storage duration of this variable, per C++ [basic.stc].
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isEscapingByref() const
Indicates the capture is a __block variable that is captured by a block that can potentially escape (...
bool isThisDeclarationADemotedDefinition() const
If this definition should pretend to be a declaration.
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
bool isInExternCXXContext() const
Determines whether this variable's context is, or is nested within, a C++ extern "C++" linkage spec.
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
bool hasDependentAlignment() const
Determines if this variable's alignment is dependent.
TemplateSpecializationKind getTemplateSpecializationKindForInstantiation() const
Get the template specialization kind of this variable for the purposes of template instantiation.
VarDecl * getDefinition()
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
bool isKnownToBeDefined() const
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
Represents a variable template specialization, which refers to a variable template with a given set o...
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration,...
bool isExplicitSpecialization() const
Represents a C array with a specified size that is not an integer-constant-expression.
Defines the Linkage enumeration and various utility functions.
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
The JSON file list parser is used to communicate input to InstallAPI.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
@ GVA_AvailableExternally
bool isReservedInAllContexts(ReservedIdentifierStatus Status)
Determine whether an identifier is reserved in all contexts.
ConstexprSpecKind
Define the kind of constexpr specifier.
Decl * getPrimaryMergedDecl(Decl *D)
Get the primary declaration for a declaration from an AST file.
InClassInitStyle
In-class initialization styles for non-static data members.
@ ICIS_NoInit
No in-class initializer.
LazyOffsetPtr< Stmt, uint64_t, &ExternalASTSource::GetExternalDeclStmt > LazyDeclStmtPtr
A lazy pointer to a statement.
Linkage getFormalLinkage(Linkage L)
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have.
StorageClass
Storage classes.
@ TSCS_thread_local
C++11 thread_local.
@ TSCS__Thread_local
C11 _Thread_local.
@ TSCS___thread
GNU __thread.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
@ VisibleNone
No linkage according to the standard, but is visible from other translation units because of types de...
@ None
No linkage, which means that the entity is unique and can only be referred to from within its scope.
@ UniqueExternal
External linkage within a unique namespace.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ External
External linkage, which indicates that the entity can be referred to from other translation units.
@ Module
Module linkage, which indicates that the entity can be referred to from other translation units withi...
@ SD_Automatic
Automatic storage duration (most local variables).
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
TagTypeKind
The kind of a tag type.
@ Struct
The "struct" keyword.
@ Enum
The "enum" keyword.
@ CanPassInRegs
The argument of this type can be passed directly in registers.
bool isLegalForVariable(StorageClass SC)
Checks whether the given storage class is legal for variables.
const FunctionProtoType * T
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
bool isReservedAtGlobalScope(ReservedIdentifierStatus Status)
Determine whether an identifier is reserved for use as a name at global scope.
bool isExternalFormalLinkage(Linkage L)
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
bool IsArmStreamingFunction(const FunctionDecl *FD, bool IncludeLocallyStreaming)
Returns whether the given FunctionDecl has an __arm[_locally]_streaming attribute.
@ StartsWithUnderscoreAndIsExternC
bool isExternallyVisible(Linkage L)
ImplicitParamKind
Defines the kind of the implicit parameter: is this an implicit parameter with pointer to 'this',...
@ Other
Other implicit parameter.
Visibility
Describes the different kinds of visibility that a declaration may have.
@ HiddenVisibility
Objects with "hidden" visibility are not seen by the dynamic linker.
@ ProtectedVisibility
Objects with "protected" visibility are seen by the dynamic linker but always dynamically resolve to ...
@ DefaultVisibility
Objects with "default" visibility are seen by the dynamic linker and act like normal objects.
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
Structure used to store a statement, the constant value to which it was evaluated (if any),...
bool HasConstantDestruction
Whether this variable is known to have constant destruction.
bool WasEvaluated
Whether this statement was already evaluated.
bool IsEvaluating
Whether this statement is being evaluated.
bool HasConstantInitialization
Whether this variable is known to have constant initialization.
bool HasICEInit
In C++98, whether the initializer is an ICE.
bool isTypeVisibility() const
unsigned IgnoreExplicitVisibility
Whether explicit visibility attributes should be ignored.
unsigned IgnoreAllVisibility
Whether all visibility should be ignored.
static LVComputationKind forLinkageOnly()
Do an LV computation when we only care about the linkage.
bool isValueVisibility() const
bool isOffset() const
Whether this pointer is currently stored as an offset.
T * get(ExternalASTSource *Source) const
Retrieve the pointer to the AST node that this lazy pointer points to.
Describes how types, statements, expressions, and declarations should be printed.
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
TemplateParameterList ** TemplParamLists
A new-allocated array of size NumTemplParamLists, containing pointers to the "outer" template paramet...
NestedNameSpecifierLoc QualifierLoc
unsigned NumTemplParamLists
The number of "outer" template parameter lists.
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Sets info about "outer" template parameter lists.
SanitizerMask Mask
Bitmask of enabled sanitizers.