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");
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();
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();
580 if (
const auto *SD = dyn_cast<LinkageSpecDecl>(D.
getDeclContext()))
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");
627 if (
const auto *Var = dyn_cast<VarDecl>(D)) {
636 if (Context.
getLangOpts().CPlusPlus && Var->getType().isConstQualified() &&
637 !Var->getType().isVolatileQualified() && !Var->isInline() &&
639 !isa<VarTemplateSpecializationDecl>(Var) &&
640 !Var->getDescribedVarTemplate()) {
645 if (Var->getStorageClass() !=
SC_Extern &&
654 Var->getStorageClass() ==
SC_None)
660 }
else if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(D)) {
662 const VarDecl *VD = IFD->getVarDecl();
663 assert(VD &&
"Expected a VarDecl in this IndirectFieldDecl!");
664 return getLVForNamespaceScopeDecl(VD, computation, IgnoreVarTypeLinkage);
666 assert(!isa<FieldDecl>(D) &&
"Didn't expect a FieldDecl!");
671 const auto *Var = dyn_cast<VarDecl>(D);
672 const auto *
Func = dyn_cast<FunctionDecl>(D);
700 !isa<TranslationUnitDecl>(DC);
702 const auto *ND = dyn_cast<NamespaceDecl>(DC);
704 if (std::optional<Visibility> Vis =
744 if (
const auto *Var = dyn_cast<VarDecl>(D)) {
768 !IgnoreVarTypeLinkage) {
769 LinkageInfo TypeLV = getLVForType(*Var->getType(), computation);
786 if (
const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
787 mergeTemplateLV(LV, spec, computation);
791 }
else if (
const auto *
Function = dyn_cast<FunctionDecl>(D)) {
807 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(
Function)))
823 TypeAsWritten = TSI->getType();
832 =
Function->getTemplateSpecializationInfo()) {
833 mergeTemplateLV(LV,
Function, specInfo, computation);
842 }
else if (
const auto *Tag = dyn_cast<TagDecl>(D)) {
844 if (!Tag->hasNameForLinkage())
850 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
851 mergeTemplateLV(LV, spec, computation);
856 }
else if (isa<EnumConstantDecl>(D)) {
864 }
else if (
const auto *temp = dyn_cast<TemplateDecl>(D)) {
875 }
else if (isa<NamespaceDecl>(D)) {
880 }
else if (isa<ObjCInterfaceDecl>(D)) {
883 }
else if (
auto *TD = dyn_cast<TypedefNameDecl>(D)) {
886 if (!TD->getAnonDeclWithTypedefName(
true))
889 }
else if (isa<MSGuidDecl>(D)) {
907LinkageComputer::getLVForClassMember(
const NamedDecl *D,
909 bool IgnoreVarTypeLinkage) {
920 if (!(isa<CXXMethodDecl>(D) ||
923 isa<IndirectFieldDecl>(D) ||
925 isa<TemplateDecl>(D)))
963 const NamedDecl *explicitSpecSuppressor =
nullptr;
965 if (
const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
968 QualType TypeAsWritten = MD->getType();
970 TypeAsWritten = TSI->getType();
977 = MD->getTemplateSpecializationInfo()) {
978 mergeTemplateLV(LV, MD, spec, computation);
980 explicitSpecSuppressor = MD;
982 explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl();
985 explicitSpecSuppressor = MD;
996 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(MD)))
999 }
else if (
const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
1000 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
1001 mergeTemplateLV(LV, spec, computation);
1003 explicitSpecSuppressor = spec;
1011 explicitSpecSuppressor = RD;
1015 }
else if (
const auto *VD = dyn_cast<VarDecl>(D)) {
1016 if (
const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(VD))
1017 mergeTemplateLV(LV, spec, computation);
1021 if (!IgnoreVarTypeLinkage) {
1031 explicitSpecSuppressor = VD;
1035 }
else if (
const auto *temp = dyn_cast<TemplateDecl>(D)) {
1036 bool considerVisibility =
1044 if (
const auto *redeclTemp = dyn_cast<RedeclarableTemplateDecl>(temp)) {
1052 assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor));
1056 bool considerClassVisibility =
true;
1057 if (explicitSpecSuppressor &&
1062 considerClassVisibility =
false;
1070void NamedDecl::anchor() {}
1093 if (isa<FieldDecl>(
this))
1095 if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(
this)) {
1099 const VarDecl *VD = IFD->getVarDecl();
1103 if (
const auto *VD = dyn_cast<VarDecl>(
this)) {
1104 if (isa<ParmVarDecl>(VD))
1110 if (
const auto *BD = dyn_cast<BindingDecl>(
this);
1112 const VarDecl *VD = BD->getHoldingVar();
1144 if (
auto *VD = dyn_cast<VarDecl>(
this))
1147 if (
auto *FD = dyn_cast<FunctionDecl>(
this))
1148 if (FD->isExternC())
1160 if (name.front() ==
'C')
1161 if (name ==
"CFStringCreateWithFormat" ||
1162 name ==
"CFStringCreateWithFormatAndArguments" ||
1163 name ==
"CFStringAppendFormat" ||
1164 name ==
"CFStringAppendFormatAndArguments")
1180 return M->isNamedModule();
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)
1599 for (
auto *I : D->
redecls()) {
1600 auto *
T = cast<NamedDecl>(I);
1603 if (!
T->isInvalidDecl() &&
T->hasCachedLinkage()) {
1625 if (isa<NamespaceDecl>(
this))
1657 bool InternalLinkage;
1658 if (
auto *ND = dyn_cast<NamedDecl>(
this))
1672 llvm_unreachable(
"unknown module kind");
1676 Name.
print(OS, Policy);
1684 std::string QualName;
1685 llvm::raw_string_ostream OS(QualName);
1708 llvm::raw_svector_ostream NameOS(NameBuffer);
1710 if (NameBuffer.empty())
1711 OS <<
"(anonymous)";
1727 if (
auto *MD = dyn_cast<ObjCMethodDecl>(
this)) {
1728 if (
auto *ID = MD->getClassInterface())
1730 }
else if (
auto *PD = dyn_cast<ObjCPropertyDecl>(
this)) {
1731 if (
auto *MD = PD->getGetterMethodDecl())
1732 if (
auto *ID = MD->getClassInterface())
1734 }
else if (
auto *ID = dyn_cast<ObjCIvarDecl>(
this)) {
1735 if (
auto *CI = ID->getContainingInterface())
1743 ContextsTy Contexts;
1749 if (
P.SuppressUnwrittenScope && isa<NamespaceDecl>(Ctx) &&
1750 cast<NamespaceDecl>(Ctx)->isAnonymousNamespace())
1755 cast<NamespaceDecl>(Ctx)->isRedundantInlineQualifierFor(NameInScope))
1759 const NamedDecl *ND = dyn_cast<NamedDecl>(Ctx);
1763 Contexts.push_back(Ctx);
1767 for (
const DeclContext *DC : llvm::reverse(Contexts)) {
1768 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1769 OS << Spec->getName();
1773 Spec->getSpecializedTemplate()->getTemplateParameters());
1774 }
else if (
const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
1775 if (ND->isAnonymousNamespace()) {
1776 OS << (
P.MSVCFormatting ?
"`anonymous namespace\'"
1777 :
"(anonymous namespace)");
1781 }
else if (
const auto *RD = dyn_cast<RecordDecl>(DC)) {
1782 if (!RD->getIdentifier())
1783 OS <<
"(anonymous " << RD->getKindName() <<
')';
1786 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(DC)) {
1788 if (FD->hasWrittenPrototype())
1789 FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<
FunctionType>());
1793 unsigned NumParams = FD->getNumParams();
1794 for (
unsigned i = 0; i < NumParams; ++i) {
1797 OS << FD->getParamDecl(i)->getType().stream(
P);
1807 }
else if (
const auto *ED = dyn_cast<EnumDecl>(DC)) {
1820 OS << *cast<NamedDecl>(DC);
1841#define DECL(Type, Base) \
1843 return isRedeclarableImpl((Type##Decl *)nullptr);
1844#define ABSTRACT_DECL(DECL)
1845#include "clang/AST/DeclNodes.inc"
1847 llvm_unreachable(
"unknown decl kind");
1851 bool IsKnownNewer)
const {
1864 if (isa<ObjCMethodDecl>(
this))
1869 if (isa<ParmVarDecl>(
this))
1881 if (
const auto *UD = dyn_cast<UsingDecl>(
this)) {
1885 cast<UsingDecl>(OldD)->getQualifier());
1887 if (
const auto *UUVD = dyn_cast<UnresolvedUsingValueDecl>(
this)) {
1891 cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
1904 for (
const auto *D :
redecls()) {
1930 llvm_unreachable(
"Linkage hasn't been computed!");
1937 llvm_unreachable(
"Non-formal linkage is not allowed here!");
1942 llvm_unreachable(
"Unhandled Linkage enum");
1945NamedDecl *NamedDecl::getUnderlyingDeclImpl() {
1947 if (
auto *UD = dyn_cast<UsingShadowDecl>(ND))
1948 ND = UD->getTargetDecl();
1950 if (
auto *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND))
1951 return AD->getClassInterface();
1953 if (
auto *AD = dyn_cast<NamespaceAliasDecl>(ND))
1954 return AD->getNamespace();
1964 if (isa<UsingShadowDecl>(D))
1965 D = cast<UsingShadowDecl>(D)->getTargetDecl();
1967 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D))
1969 if (
const auto *MD = dyn_cast_if_present<CXXMethodDecl>(D->
getAsFunction()))
1970 return MD->isInstance();
1978template <
typename DeclT>
1980 if (
decl->getNumTemplateParameterLists() > 0)
1981 return decl->getTemplateParameterList(0)->getTemplateLoc();
1982 return decl->getInnerLocStart();
2000 if (!hasExtInfo()) {
2006 getExtInfo()->TInfo = savedTInfo;
2009 getExtInfo()->QualifierLoc = QualifierLoc;
2010 }
else if (hasExtInfo()) {
2012 getExtInfo()->QualifierLoc = QualifierLoc;
2017 assert(TrailingRequiresClause);
2019 if (!hasExtInfo()) {
2025 getExtInfo()->TInfo = savedTInfo;
2028 getExtInfo()->TrailingRequiresClause = TrailingRequiresClause;
2033 assert(!TPLists.empty());
2035 if (!hasExtInfo()) {
2041 getExtInfo()->TInfo = savedTInfo;
2044 getExtInfo()->setTemplateParameterListsInfo(Context, TPLists);
2062 case Type::BlockPointer:
2065 case Type::MemberPointer:
2068 case Type::LValueReference:
2069 case Type::RValueReference:
2072 case Type::PackExpansion:
2073 QT = cast<PackExpansionType>(
T)->getPattern();
2076 case Type::ConstantArray:
2077 case Type::DependentSizedArray:
2078 case Type::IncompleteArray:
2079 case Type::VariableArray:
2080 case Type::FunctionProto:
2081 case Type::FunctionNoProto:
2093 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
2107 if (!TPLists.empty()) {
2128 llvm_unreachable(
"Invalid storage class");
2137 static_assert(
sizeof(VarDeclBitfields) <=
sizeof(
unsigned),
2138 "VarDeclBitfields too large!");
2140 "ParmVarDeclBitfields too large!");
2142 "NonParmVarDeclBitfields too large!");
2151 return new (
C, DC)
VarDecl(Var,
C, DC, StartL, IdL,
Id,
T, TInfo, S);
2168 if (!hasAttr<ThreadAttr>() &&
2171 hasAttr<OMPThreadPrivateDeclAttr>()))
2175 hasAttr<OMPThreadPrivateDeclAttr>())
2184 llvm_unreachable(
"Unknown thread storage class specifier!");
2202 if (!D.hasExternalFormalLinkage())
2207 if (!D.getASTContext().getLangOpts().CPlusPlus)
2231 assert(D.getASTContext().getLangOpts().CPlusPlus);
2286 isa<VarTemplatePartialSpecializationDecl>(
this)))
2305 if (
const auto *SAA = getAttr<SelectAnyAttr>())
2306 if (!SAA->isInherited())
2312 if (
auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(
this)) {
2314 !isa<VarTemplatePartialSpecializationDecl>(VTSD) &&
2315 !VTSD->IsCompleteDefinition)
2347 VarDecl *LastTentative =
nullptr;
2352 Kind =
Decl->isThisDeclarationADefinition();
2357 LastTentative =
Decl;
2360 return LastTentative;
2366 if (I->isThisDeclarationADefinition(
C) ==
Definition)
2377 Kind = std::max(
Kind, I->isThisDeclarationADefinition(
C));
2387 if (
auto Expr = I->getInit()) {
2396 if (
auto *
P = dyn_cast<ParmVarDecl>(
this))
2397 if (
P->hasUnparsedDefaultArg() ||
P->hasUninstantiatedDefaultArg())
2400 return !
Init.isNull();
2407 if (
auto *S =
Init.dyn_cast<
Stmt *>())
2408 return cast<Expr>(S);
2411 return cast<Expr>(Eval->Value.isOffset()
2413 : Eval->Value.get(
nullptr));
2418 return ES->Value.getAddressOfPointer(
getASTContext().getExternalSource());
2420 return Init.getAddrOfPtr1();
2429 if (I->isThisDeclarationADefinition()) {
2456 Eval->~EvaluatedStmt();
2468 if (!Lang.CPlusPlus && !Lang.OpenCL && !Lang.C23)
2472 if (isa<ParmVarDecl>(
this))
2481 if (Lang.CPlusPlus11 &&
getType()->isReferenceType())
2492 if (
getType()->isIntegralOrEnumerationType() && !Lang.C23)
2502 return (Lang.CPlusPlus11 || Lang.C23) &&
isConstexpr();
2509 const VarDecl *DefVD =
nullptr;
2511 if (!
Init ||
Init->isValueDependent() ||
getType()->isDependentType())
2557 bool IsConstantInitialization)
const {
2561 assert(!
Init->isValueDependent());
2578 IsConstantInitialization);
2584 if (IsConstantInitialization &&
2614 assert(
Init &&
"no initializer");
2644 "already evaluated var value before checking for constant init");
2647 "only meaningful in C++/C23");
2649 assert(!
getInit()->isValueDependent());
2653 evaluateValueImpl(Notes,
true) && Notes.empty();
2664 return isa<PackExpansionType>(
getType());
2667template<
typename DeclT>
2670 if (
auto *Def = D->getDefinition())
2686 llvm::any_of(specific_attrs<AlignedAttr>(), [](
const AlignedAttr *AA) {
2687 return AA->isAlignmentDependent();
2706 if (
auto *VDTemplSpec = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2708 auto From = VDTemplSpec->getInstantiatedFrom();
2710 while (!VTD->isMemberSpecialization()) {
2711 auto *NewVTD = VTD->getInstantiatedFromMemberTemplate();
2720 while (!VTPSD->isMemberSpecialization()) {
2721 auto *NewVTPSD = VTPSD->getInstantiatedFromMember();
2726 return getDefinitionOrSelf<VarDecl>(VTPSD);
2734 while (!VarTemplate->isMemberSpecialization()) {
2735 auto *NewVT = VarTemplate->getInstantiatedFromMemberTemplate();
2738 VarTemplate = NewVT;
2751 return cast<VarDecl>(MSI->getInstantiatedFrom());
2757 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2758 return Spec->getSpecializationKind();
2761 return MSI->getTemplateSpecializationKind();
2769 return MSI->getTemplateSpecializationKind();
2771 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2772 return Spec->getSpecializationKind();
2778 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2779 return Spec->getPointOfInstantiation();
2782 return MSI->getPointOfInstantiation();
2805 if (LangOpts.CUDA && !LangOpts.GPURelocatableDeviceCode &&
2807 isa<IncompleteArrayType>(
getType()))
2816 !hasAttr<AlwaysDestroyAttr>()));
2832 assert(
hasInit() &&
"Expect initializer to check for flexible array init");
2834 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2836 auto *List = dyn_cast<InitListExpr>(
getInit()->IgnoreParens());
2839 const Expr *FlexibleInit = List->getInit(List->getNumInits() - 1);
2847 assert(
hasInit() &&
"Expect initializer to check for flexible array init");
2849 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2851 auto *List = dyn_cast<InitListExpr>(
getInit()->IgnoreParens());
2852 if (!List || List->getNumInits() == 0)
2854 const Expr *FlexibleInit = List->getInit(List->getNumInits() - 1);
2862 if (FlexibleArrayOffset + FlexibleArraySize < RL.
getSize())
2864 return FlexibleArrayOffset + FlexibleArraySize - RL.
getSize();
2878 assert((isa<VarTemplateSpecializationDecl>(
this) ||
2880 "not a variable or static data member template specialization");
2883 dyn_cast<VarTemplateSpecializationDecl>(
this)) {
2884 Spec->setSpecializationKind(TSK);
2886 PointOfInstantiation.
isValid() &&
2887 Spec->getPointOfInstantiation().isInvalid()) {
2888 Spec->setPointOfInstantiation(PointOfInstantiation);
2890 L->InstantiationRequested(
this);
2893 MSI->setTemplateSpecializationKind(TSK);
2895 MSI->getPointOfInstantiation().isInvalid()) {
2896 MSI->setPointOfInstantiation(PointOfInstantiation);
2898 L->InstantiationRequested(
this);
2906 assert(
getASTContext().getTemplateOrSpecializationInfo(
this).isNull() &&
2907 "Previous template or instantiation?");
2920 return new (
C, DC)
ParmVarDecl(ParmVar,
C, DC, StartLoc, IdLoc,
Id,
T, TInfo,
2927 if (
const auto *DT = dyn_cast<DecayedType>(
T))
2928 return DT->getOriginalType();
2955 if (hasAttr<NSConsumedAttr>())
2961 if (RT && RT->getDecl()->isParamDestroyedInCallee() &&
2971 "Default argument is not yet instantiated!");
2974 if (
auto *E = dyn_cast_if_present<FullExpr>(Arg))
2975 return E->getSubExpr();
2997 return E->getSourceRange();
3002 llvm_unreachable(
"Invalid default argument kind.");
3012 "Wrong kind of initialization expression!");
3013 return cast_if_present<Expr>(
Init.get<
Stmt *>());
3024void ParmVarDecl::setParameterIndexLarge(
unsigned parameterIndex) {
3029unsigned ParmVarDecl::getParameterIndexLarge()
const {
3041 bool UsesFPIntrin,
bool isInlineSpecified,
3043 Expr *TrailingRequiresClause)
3047 EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.
getInfo()) {
3077 if (TrailingRequiresClause)
3090 if (
const auto *FT =
getType()->getAs<FunctionProtoType>())
3091 return FT->isVariadic();
3099 static constexpr size_t Alignment =
3102 size_t Size = totalSizeToAlloc<DeclAccessPair, StringLiteral *>(
3103 Lookups.size(), DeletedMessage !=
nullptr);
3107 Info->NumLookups = Lookups.size();
3108 Info->HasDeletedMessage = DeletedMessage !=
nullptr;
3110 std::uninitialized_copy(Lookups.begin(), Lookups.end(),
3113 *Info->getTrailingObjects<
StringLiteral *>() = DeletedMessage;
3119 assert(!
FunctionDeclBits.HasDefaultedOrDeletedInfo &&
"already have this");
3120 assert(!
Body &&
"can't replace function body with defaulted function info");
3145 assert(HasDeletedMessage &&
3146 "No space to store a delete message in this DefaultedOrDeletedInfo");
3147 *getTrailingObjects<StringLiteral *>() = Message;
3157 for (
const auto *I :
redecls()) {
3158 if (I->doesThisDeclarationHaveABody()) {
3175 if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
3188 return InstantiatedFrom->getFriendObjectKind() &&
3189 InstantiatedFrom->isThisDeclarationADefinition();
3196 return InstantiatedFrom->getFriendObjectKind() &&
3197 InstantiatedFrom->isThisDeclarationADefinition();
3204 bool CheckForPendingFriendDefinition)
const {
3206 if (FD->isThisDeclarationADefinition()) {
3226 if (CheckForPendingFriendDefinition &&
3227 FD->isThisDeclarationInstantiatedFromAFriendDefinition()) {
3240 assert(!
Definition->FunctionDeclBits.HasDefaultedOrDeletedInfo &&
3241 "definition should not have a body");
3259 Parent->markedVirtualFunctionPure();
3262template<std::
size_t Len>
3265 return II && II->
isStr(Str);
3299 if (
const auto *MD = dyn_cast<CXXMethodDecl>(
this);
3300 MD && MD->isLambdaStaticInvoker())
3301 return MD->getParent()->getLambdaCallOperator()->isImmediateFunction();
3331 return llvm::StringSwitch<bool>(
getName())
3344 if (
getDeclName().getCXXOverloadedOperator() != OO_New &&
3345 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3346 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3347 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3354 if (proto->getNumParams() != 2 || proto->isVariadic())
3363 return (proto->getParamType(1).getCanonicalType() == Context.
VoidPtrTy);
3367 std::optional<unsigned> *AlignmentParam,
bool *IsNothrow)
const {
3370 if (
getDeclName().getCXXOverloadedOperator() != OO_New &&
3371 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3372 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3373 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3384 if (FPT->getNumParams() == 0 || FPT->getNumParams() > 4 || FPT->isVariadic())
3389 if (FPT->getNumParams() == 1)
3392 unsigned Params = 1;
3393 QualType Ty = FPT->getParamType(Params);
3396 auto Consume = [&] {
3398 Ty = Params < FPT->getNumParams() ? FPT->getParamType(Params) :
QualType();
3402 bool IsSizedDelete =
false;
3404 (
getDeclName().getCXXOverloadedOperator() == OO_Delete ||
3405 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete) &&
3407 IsSizedDelete =
true;
3416 *AlignmentParam = Params;
3439 T = TD->getDecl()->getUnderlyingType();
3442 if (II && II->
isStr(
"__hot_cold_t"))
3446 return Params == FPT->getNumParams();
3471 llvm_unreachable(
"Unknown GVALinkage");
3485 RD->getIdentifier()->isStr(
"destroying_delete_t");
3497 if (hasAttr<OpenCLKernelAttr>())
3507 if (
const auto *Method = dyn_cast<CXXMethodDecl>(
this))
3508 return Method->isStatic();
3516 if (
const auto *Namespace = cast<NamespaceDecl>(DC)) {
3517 if (!Namespace->getDeclName())
3526 if (hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
3527 hasAttr<C11NoReturnAttr>())
3530 if (
auto *FnTy =
getType()->getAs<FunctionType>())
3531 return FnTy->getNoReturnAttr();
3559 if (hasAttr<TargetAttr>())
3561 if (hasAttr<TargetVersionAttr>())
3563 if (hasAttr<CPUDispatchAttr>())
3565 if (hasAttr<CPUSpecificAttr>())
3567 if (hasAttr<TargetClonesAttr>())
3582 (hasAttr<TargetAttr>() || hasAttr<TargetVersionAttr>());
3588 if (hasAttr<TargetAttr>())
3589 return getAttr<TargetAttr>()->isDefaultVersion();
3590 return hasAttr<TargetVersionAttr>() &&
3591 getAttr<TargetVersionAttr>()->isDefaultVersion();
3609 assert((!PrevDecl || PrevFunTmpl) &&
"Function/function template mismatch");
3610 FunTmpl->setPreviousDecl(PrevFunTmpl);
3633 unsigned BuiltinID = 0;
3635 if (
const auto *ABAA = getAttr<ArmBuiltinAliasAttr>()) {
3636 BuiltinID = ABAA->getBuiltinName()->getBuiltinID();
3637 }
else if (
const auto *BAA = getAttr<BuiltinAliasAttr>()) {
3638 BuiltinID = BAA->getBuiltinName()->getBuiltinID();
3639 }
else if (
const auto *A = getAttr<BuiltinAttr>()) {
3640 BuiltinID = A->getID();
3648 if (!ConsiderWrapperFunctions && hasAttr<OverloadableAttr>() &&
3649 (!hasAttr<ArmBuiltinAliasAttr>() && !hasAttr<BuiltinAliasAttr>()))
3672 if (Context.
getLangOpts().CUDA && hasAttr<CUDADeviceAttr>() &&
3673 !hasAttr<CUDAHostAttr>() &&
3674 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3683 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3699 assert(!ParamInfo &&
"Already has param info!");
3700 assert(NewParamInfo.size() ==
getNumParams() &&
"Parameter count mismatch!");
3703 if (!NewParamInfo.empty()) {
3705 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
3719 unsigned NumRequiredArgs = 0;
3720 unsigned MinParamsSoFar = 0;
3722 if (!Param->isParameterPack()) {
3724 if (!Param->hasDefaultArg())
3725 NumRequiredArgs = MinParamsSoFar;
3728 return NumRequiredArgs;
3758 assert(
isInlined() &&
"expected to get called on an inlined function!");
3762 !hasAttr<DLLExportAttr>())
3767 if (!FD->isImplicit() && FD->getStorageClass() ==
SC_Extern)
3779 if (!FD->isImplicit() && FD->getStorageClass() ==
SC_Extern)
3809 "Must have a declaration without a body.");
3823 if (Context.
getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3833 bool FoundBody =
false;
3858 bool FoundBody =
false;
3883 !
SM.isBeforeInTranslationUnit(RTRange.
getEnd(), Boundary))
3929 hasAttr<AliasAttr>()) &&
3930 "Must be a function definition");
3931 assert(
isInlined() &&
"Function must be inline");
3934 if (Context.
getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3948 for (
auto *Redecl :
redecls()) {
3949 if (Redecl->isInlineSpecified() &&
3959 "should not use C inline rules in C++");
3965 for (
auto *Redecl :
redecls()) {
3994 if (TemplateOrSpecialization.isNull())
3996 if (
const auto *ND = TemplateOrSpecialization.dyn_cast<
NamedDecl *>()) {
3997 if (isa<FunctionDecl>(ND))
3999 assert(isa<FunctionTemplateDecl>(ND) &&
4000 "No other valid types in NamedDecl");
4007 if (TemplateOrSpecialization.is
4011 llvm_unreachable(
"Did we miss a TemplateOrSpecialization type?");
4016 return cast<FunctionDecl>(Info->getInstantiatedFrom());
4025 if (
auto *FTSI = TemplateOrSpecialization
4026 .dyn_cast<FunctionTemplateSpecializationInfo *>())
4027 return FTSI->getMemberSpecializationInfo();
4032FunctionDecl::setInstantiationOfMemberFunction(
ASTContext &
C,
4035 assert(TemplateOrSpecialization.isNull() &&
4036 "Member function is already a specialization");
4039 TemplateOrSpecialization = Info;
4043 return dyn_cast_if_present<FunctionTemplateDecl>(
4044 TemplateOrSpecialization.dyn_cast<
NamedDecl *>());
4049 assert(TemplateOrSpecialization.isNull() &&
4050 "Member function is already a specialization");
4051 TemplateOrSpecialization = Template;
4056 TemplateOrSpecialization
4057 .is<DependentFunctionTemplateSpecializationInfo *>();
4061 assert(TemplateOrSpecialization.isNull() &&
4062 "Function is already a specialization");
4063 TemplateOrSpecialization = FD;
4067 return dyn_cast_if_present<FunctionDecl>(
4068 TemplateOrSpecialization.dyn_cast<
NamedDecl *>());
4092 bool HasPattern =
false;
4094 HasPattern = PatternDecl->
hasBody(PatternDecl);
4100 if (!HasPattern || !PatternDecl)
4124 dyn_cast<CXXMethodDecl>(
this))) {
4136 if (ForDefinition &&
4142 if (ForDefinition &&
4149 while (!ForDefinition || !Primary->isMemberSpecialization()) {
4150 auto *NewPrimary = Primary->getInstantiatedFromMemberTemplate();
4153 Primary = NewPrimary;
4164 = TemplateOrSpecialization
4165 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4166 return Info->getTemplate();
4173 return TemplateOrSpecialization
4180 = TemplateOrSpecialization
4181 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4182 return Info->TemplateArguments;
4190 = TemplateOrSpecialization
4191 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4192 return Info->TemplateArgumentsAsWritten;
4195 TemplateOrSpecialization
4196 .dyn_cast<DependentFunctionTemplateSpecializationInfo *>()) {
4197 return Info->TemplateArgumentsAsWritten;
4203FunctionDecl::setFunctionTemplateSpecialization(
ASTContext &
C,
4210 assert((TemplateOrSpecialization.isNull() ||
4212 "Member function is already a specialization");
4214 "Must specify the type of function template specialization");
4215 assert((TemplateOrSpecialization.isNull() ||
4218 "Member specialization must be an explicit specialization");
4221 C,
this, Template, TSK, TemplateArgs, TemplateArgsAsWritten,
4222 PointOfInstantiation,
4224 TemplateOrSpecialization = Info;
4231 assert(TemplateOrSpecialization.isNull());
4235 TemplateOrSpecialization = Info;
4240 return TemplateOrSpecialization
4248 const auto *TArgsWritten =
4251 totalSizeToAlloc<FunctionTemplateDecl *>(Candidates.
size())))
4255DependentFunctionTemplateSpecializationInfo::
4256 DependentFunctionTemplateSpecializationInfo(
4259 : NumCandidates(Candidates.size()),
4260 TemplateArgumentsAsWritten(TemplateArgsWritten) {
4261 std::transform(Candidates.
begin(), Candidates.
end(),
4262 getTrailingObjects<FunctionTemplateDecl *>(),
4264 return cast<FunctionTemplateDecl>(ND->getUnderlyingDecl());
4272 TemplateOrSpecialization
4273 .dyn_cast<FunctionTemplateSpecializationInfo *>())
4274 return FTSInfo->getTemplateSpecializationKind();
4278 return MSInfo->getTemplateSpecializationKind();
4282 if (TemplateOrSpecialization
4283 .is<DependentFunctionTemplateSpecializationInfo *>() &&
4315 TemplateOrSpecialization
4316 .dyn_cast<FunctionTemplateSpecializationInfo *>()) {
4317 if (
auto *MSInfo = FTSInfo->getMemberSpecializationInfo())
4318 return MSInfo->getTemplateSpecializationKind();
4319 return FTSInfo->getTemplateSpecializationKind();
4324 return MSInfo->getTemplateSpecializationKind();
4326 if (TemplateOrSpecialization
4327 .is<DependentFunctionTemplateSpecializationInfo *>() &&
4338 = TemplateOrSpecialization.dyn_cast<
4340 FTSInfo->setTemplateSpecializationKind(TSK);
4342 PointOfInstantiation.
isValid() &&
4343 FTSInfo->getPointOfInstantiation().isInvalid()) {
4344 FTSInfo->setPointOfInstantiation(PointOfInstantiation);
4346 L->InstantiationRequested(
this);
4350 MSInfo->setTemplateSpecializationKind(TSK);
4352 PointOfInstantiation.
isValid() &&
4353 MSInfo->getPointOfInstantiation().isInvalid()) {
4354 MSInfo->setPointOfInstantiation(PointOfInstantiation);
4356 L->InstantiationRequested(
this);
4359 llvm_unreachable(
"Function cannot have a template specialization kind");
4364 = TemplateOrSpecialization.dyn_cast<
4366 return FTSInfo->getPointOfInstantiation();
4369 return MSInfo->getPointOfInstantiation();
4390 if (FunTmpl->getTemplatedDecl()->hasBody(
Definition))
4409 case Builtin::BI__builtin_memset:
4410 case Builtin::BI__builtin___memset_chk:
4411 case Builtin::BImemset:
4412 return Builtin::BImemset;
4414 case Builtin::BI__builtin_memcpy:
4415 case Builtin::BI__builtin___memcpy_chk:
4416 case Builtin::BImemcpy:
4417 return Builtin::BImemcpy;
4419 case Builtin::BI__builtin_mempcpy:
4420 case Builtin::BI__builtin___mempcpy_chk:
4421 case Builtin::BImempcpy:
4422 return Builtin::BImempcpy;
4424 case Builtin::BI__builtin_memmove:
4425 case Builtin::BI__builtin___memmove_chk:
4426 case Builtin::BImemmove:
4427 return Builtin::BImemmove;
4429 case Builtin::BIstrlcpy:
4430 case Builtin::BI__builtin___strlcpy_chk:
4431 return Builtin::BIstrlcpy;
4433 case Builtin::BIstrlcat:
4434 case Builtin::BI__builtin___strlcat_chk:
4435 return Builtin::BIstrlcat;
4437 case Builtin::BI__builtin_memcmp:
4438 case Builtin::BImemcmp:
4439 return Builtin::BImemcmp;
4441 case Builtin::BI__builtin_bcmp:
4442 case Builtin::BIbcmp:
4443 return Builtin::BIbcmp;
4445 case Builtin::BI__builtin_strncpy:
4446 case Builtin::BI__builtin___strncpy_chk:
4447 case Builtin::BIstrncpy:
4448 return Builtin::BIstrncpy;
4450 case Builtin::BI__builtin_strncmp:
4451 case Builtin::BIstrncmp:
4452 return Builtin::BIstrncmp;
4454 case Builtin::BI__builtin_strncasecmp:
4455 case Builtin::BIstrncasecmp:
4456 return Builtin::BIstrncasecmp;
4458 case Builtin::BI__builtin_strncat:
4459 case Builtin::BI__builtin___strncat_chk:
4460 case Builtin::BIstrncat:
4461 return Builtin::BIstrncat;
4463 case Builtin::BI__builtin_strndup:
4464 case Builtin::BIstrndup:
4465 return Builtin::BIstrndup;
4467 case Builtin::BI__builtin_strlen:
4468 case Builtin::BIstrlen:
4469 return Builtin::BIstrlen;
4471 case Builtin::BI__builtin_bzero:
4472 case Builtin::BIbzero:
4473 return Builtin::BIbzero;
4475 case Builtin::BI__builtin_bcopy:
4476 case Builtin::BIbcopy:
4477 return Builtin::BIbcopy;
4479 case Builtin::BIfree:
4480 return Builtin::BIfree;
4484 if (FnInfo->
isStr(
"memset"))
4485 return Builtin::BImemset;
4486 if (FnInfo->
isStr(
"memcpy"))
4487 return Builtin::BImemcpy;
4488 if (FnInfo->
isStr(
"mempcpy"))
4489 return Builtin::BImempcpy;
4490 if (FnInfo->
isStr(
"memmove"))
4491 return Builtin::BImemmove;
4492 if (FnInfo->
isStr(
"memcmp"))
4493 return Builtin::BImemcmp;
4494 if (FnInfo->
isStr(
"bcmp"))
4495 return Builtin::BIbcmp;
4496 if (FnInfo->
isStr(
"strncpy"))
4497 return Builtin::BIstrncpy;
4498 if (FnInfo->
isStr(
"strncmp"))
4499 return Builtin::BIstrncmp;
4500 if (FnInfo->
isStr(
"strncasecmp"))
4501 return Builtin::BIstrncasecmp;
4502 if (FnInfo->
isStr(
"strncat"))
4503 return Builtin::BIstrncat;
4504 if (FnInfo->
isStr(
"strndup"))
4505 return Builtin::BIstrndup;
4506 if (FnInfo->
isStr(
"strlen"))
4507 return Builtin::BIstrlen;
4508 if (FnInfo->
isStr(
"bzero"))
4509 return Builtin::BIbzero;
4510 if (FnInfo->
isStr(
"bcopy"))
4511 return Builtin::BIbcopy;
4513 if (FnInfo->
isStr(
"free"))
4514 return Builtin::BIfree;
4522 assert(hasODRHash());
4531 setHasODRHash(
true);
4538 setHasODRHash(
true);
4552 return new (
C, DC)
FieldDecl(Decl::Field, DC, StartLoc, IdLoc,
Id,
T, TInfo,
4553 BW, Mutable, InitStyle);
4567 return Record->getDecl()->isAnonymousStructOrUnion();
4577 return cast_if_present<Expr>(
4579 : InitPtr.
get(
nullptr));
4611 if (!hasAttr<NoUniqueAddressAttr>())
4620 assert(
isInvalidDecl() &&
"valid field has incomplete type");
4626 const auto *CXXRD = cast<CXXRecordDecl>(RD);
4627 if (!CXXRD->isEmpty())
4637 return !llvm::any_of(CXXRD->fields(), [](
const FieldDecl *Field) {
4638 return Field->getType()->getAs<RecordType>();
4648 if (Canonical !=
this)
4651 if (CachedFieldIndex)
return CachedFieldIndex - 1;
4655 assert(RD &&
"requested index for field of struct with no definition");
4657 for (
auto *Field : RD->
fields()) {
4658 Field->getCanonicalDecl()->CachedFieldIndex = Index + 1;
4659 assert(Field->getCanonicalDecl()->CachedFieldIndex == Index + 1 &&
4660 "overflow in field numbering");
4664 assert(CachedFieldIndex &&
"failed to find field in parent");
4665 return CachedFieldIndex - 1;
4679 "capturing type in non-lambda or captured record.");
4680 assert(StorageKind == ISK_NoInit && !BitField &&
4681 "bit-field or field with default member initializer cannot capture "
4683 StorageKind = ISK_CapturedVLAType;
4707 "EnumDecl not matched with TagTypeKind::Enum");
4715 TagDeclBits.IsThisDeclarationADemotedDefinition =
false;
4731 TypedefNameDeclOrQualifier = TDD;
4742 if (
auto *D = dyn_cast<CXXRecordDecl>(
this)) {
4743 struct CXXRecordDecl::DefinitionData *
Data =
4744 new (
getASTContext())
struct CXXRecordDecl::DefinitionData(D);
4746 cast<CXXRecordDecl>(I)->DefinitionData =
Data;
4751 assert((!isa<CXXRecordDecl>(
this) ||
4753 "definition completed but not started");
4759 L->CompletedTagDefinition(
this);
4764 return const_cast<TagDecl *
>(
this);
4769 if (II->isOutOfDate()) {
4775 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(
this))
4776 return CXXRD->getDefinition();
4779 if (R->isCompleteDefinition())
4795 if (getExtInfo()->NumTemplParamLists == 0) {
4809 if (Name.isIdentifier() && !Name.getAsIdentifierInfo()) {
4814 Copy.SuppressScope =
true;
4819 Name.print(OS, Policy);
4824 assert(!TPLists.empty());
4839 bool Scoped,
bool ScopedUsingClassTag,
bool Fixed)
4841 assert(Scoped || !ScopedUsingClassTag);
4842 IntegerType =
nullptr;
4843 setNumPositiveBits(0);
4844 setNumNegativeBits(0);
4846 setScopedUsingClassTag(ScopedUsingClassTag);
4848 setHasODRHash(
false);
4852void EnumDecl::anchor() {}
4858 bool IsScopedUsingClassTag,
bool IsFixed) {
4860 IsScoped, IsScopedUsingClassTag, IsFixed);
4861 Enum->setMayHaveOutOfDateDef(
C.getLangOpts().Modules);
4862 C.getTypeDeclType(
Enum, PrevDecl);
4869 nullptr,
nullptr,
false,
false,
false);
4870 Enum->setMayHaveOutOfDateDef(
C.getLangOpts().Modules);
4876 return TI->getTypeLoc().getSourceRange();
4882 unsigned NumPositiveBits,
4883 unsigned NumNegativeBits) {
4887 PromotionType = NewPromotionType;
4888 setNumPositiveBits(NumPositiveBits);
4889 setNumNegativeBits(NumNegativeBits);
4894 if (
const auto *A = getAttr<EnumExtensibilityAttr>())
4895 return A->getExtensibility() == EnumExtensibilityAttr::Closed;
4900 return isClosed() && hasAttr<FlagEnumAttr>();
4904 return isClosed() && !hasAttr<FlagEnumAttr>();
4909 return MSI->getTemplateSpecializationKind();
4917 assert(MSI &&
"Not an instantiated member enumeration?");
4920 PointOfInstantiation.
isValid() &&
4936 "couldn't find pattern for enum instantiation");
4941 if (SpecializationInfo)
4949 assert(!SpecializationInfo &&
"Member enum is already a specialization");
4959 setHasODRHash(
true);
4970 Res.setEnd(TSI->getTypeLoc().getEndLoc());
4980 if (NumNegativeBits) {
4981 unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1);
4982 Max = llvm::APInt(Bitwidth, 1) << (NumBits - 1);
4985 Max = llvm::APInt(Bitwidth, 1) << NumPositiveBits;
4986 Min = llvm::APInt::getZero(Bitwidth);
4998 :
TagDecl(DK, TK,
C, DC, IdLoc,
Id, PrevDecl, StartLoc) {
4999 assert(
classof(
static_cast<Decl *
>(
this)) &&
"Invalid Kind!");
5021 StartLoc, IdLoc,
Id, PrevDecl);
5024 C.getTypeDeclType(R, PrevDecl);
5043 if (
auto RD = dyn_cast<CXXRecordDecl>(
this))
5044 return RD->isLambda();
5049 return hasAttr<CapturedRecordAttr>();
5061 for (
const FieldDecl *FD : Def->fields()) {
5073 LoadFieldsFromExternalStorage();
5077 return D->field_begin();
5105 return hasAttr<MSStructAttr>() ||
C.getLangOpts().MSBitfields == 1;
5114void RecordDecl::LoadFieldsFromExternalStorage()
const {
5129 for (
unsigned i=0, e=Decls.size(); i != e; ++i)
5130 assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i]));
5136 auto [ExternalFirst, ExternalLast] =
5139 ExternalLast->NextInContextAndBits.setPointer(
FirstDecl);
5148 (SanitizerKind::Address | SanitizerKind::KernelAddress);
5149 if (!EnabledAsanMask || !Context.
getLangOpts().SanitizeAddressFieldPadding)
5152 const auto *CXXRD = dyn_cast<CXXRecordDecl>(
this);
5154 int ReasonToReject = -1;
5155 if (!CXXRD || CXXRD->isExternCContext())
5157 else if (CXXRD->hasAttr<PackedAttr>())
5159 else if (CXXRD->isUnion())
5161 else if (CXXRD->isTriviallyCopyable())
5163 else if (CXXRD->hasTrivialDestructor())
5165 else if (CXXRD->isStandardLayout())
5175 if (ReasonToReject >= 0)
5178 diag::remark_sanitize_address_insert_extra_padding_rejected)
5183 diag::remark_sanitize_address_insert_extra_padding_accepted)
5186 return ReasonToReject < 0;
5190 for (
const auto *I :
fields()) {
5191 if (I->getIdentifier())
5194 if (
const auto *RT = I->getType()->getAs<
RecordType>())
5196 RT->getDecl()->findFirstNamedDataMember())
5197 return NamedDataMember;
5232 assert(!ParamInfo &&
"Already has param info!");
5235 if (!NewParamInfo.empty()) {
5236 NumParams = NewParamInfo.size();
5238 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
5243 bool CapturesCXXThis) {
5245 this->NumCaptures = Captures.size();
5247 if (Captures.empty()) {
5248 this->Captures =
nullptr;
5252 this->Captures = Captures.copy(Context).data();
5258 if (I.getVariable() == variable)
5272void TranslationUnitDecl::anchor() {}
5279 AnonymousNamespace = D;
5282 Listener->AddedAnonymousNamespace(
this, D);
5285void PragmaCommentDecl::anchor() {}
5293 new (
C, DC, additionalSizeToAlloc<char>(Arg.size() + 1))
5295 memcpy(PCD->getTrailingObjects<
char>(), Arg.data(), Arg.size());
5296 PCD->getTrailingObjects<
char>()[Arg.size()] =
'\0';
5303 return new (
C,
ID, additionalSizeToAlloc<char>(ArgSize + 1))
5307void PragmaDetectMismatchDecl::anchor() {}
5313 size_t ValueStart = Name.size() + 1;
5315 new (
C, DC, additionalSizeToAlloc<char>(ValueStart +
Value.size() + 1))
5317 memcpy(PDMD->getTrailingObjects<
char>(), Name.data(), Name.size());
5318 PDMD->getTrailingObjects<
char>()[Name.size()] =
'\0';
5319 memcpy(PDMD->getTrailingObjects<
char>() + ValueStart,
Value.data(),
5321 PDMD->getTrailingObjects<
char>()[ValueStart +
Value.size()] =
'\0';
5327 unsigned NameValueSize) {
5328 return new (
C,
ID, additionalSizeToAlloc<char>(NameValueSize + 1))
5332void ExternCContextDecl::anchor() {}
5339void LabelDecl::anchor() {}
5343 return new (
C, DC)
LabelDecl(DC, IdentL, II,
nullptr, IdentL);
5349 assert(GnuLabelL != IdentL &&
"Use this only for GNU local labels");
5350 return new (
C, DC)
LabelDecl(DC, IdentL, II,
nullptr, GnuLabelL);
5359char *Buffer =
new (
getASTContext(), 1)
char[Name.size() + 1];
5360 memcpy(Buffer, Name.data(), Name.size());
5361 Buffer[Name.size()] =
'\0';
5365void ValueDecl::anchor() {}
5369 return MostRecent->hasAttr<WeakAttr>() ||
5374 if (
auto *Var = llvm::dyn_cast<VarDecl>(
this))
5375 return Var->isInitCapture();
5379void ImplicitParamDecl::anchor() {}
5402 bool isInlineSpecified,
bool hasWrittenPrototype,
5404 Expr *TrailingRequiresClause) {
5426CapturedDecl::CapturedDecl(
DeclContext *DC,
unsigned NumParams)
5428 NumParams(NumParams), ContextParam(0), BodyAndNothrow(nullptr,
false) {}
5431 unsigned NumParams) {
5432 return new (
C, DC, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
5437 unsigned NumParams) {
5438 return new (
C,
ID, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
5458 Expr *E,
const llvm::APSInt &
V) {
5465 QualType(),
nullptr, llvm::APSInt());
5468void IndirectFieldDecl::anchor() {}
5474 :
ValueDecl(IndirectField, DC, L, N,
T), Chaining(CH.data()),
5475 ChainingSize(CH.size()) {
5478 if (
C.getLangOpts().CPlusPlus)
5499 End =
Init->getEndLoc();
5503void TypeDecl::anchor() {}
5512void TypedefNameDecl::anchor() {}
5517 auto *ThisTypedef =
this;
5518 if (AnyRedecl && OwningTypedef) {
5522 if (OwningTypedef == ThisTypedef)
5523 return TT->getDecl();
5529bool TypedefNameDecl::isTransparentTagSlow()
const {
5530 auto determineIsTransparent = [&]() {
5532 if (
auto *TD = TT->getDecl()) {
5533 if (TD->getName() !=
getName())
5540 return SM.getSpellingLoc(TTLoc) ==
SM.getSpellingLoc(TDLoc);
5546 bool isTransparent = determineIsTransparent();
5547 MaybeModedTInfo.setInt((isTransparent << 1) | 1);
5548 return isTransparent;
5574 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
5582 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
5586void FileScopeAsmDecl::anchor() {}
5601void TopLevelStmtDecl::anchor() {}
5604 assert(
C.getLangOpts().IncrementalExtensions &&
5605 "Must be used only in incremental mode");
5629void EmptyDecl::anchor() {}
5639HLSLBufferDecl::HLSLBufferDecl(
DeclContext *DC,
bool CBuffer,
5644 IsCBuffer(CBuffer) {}
5692 :
Decl(
Import, DC, StartLoc), ImportedModule(Imported),
5693 NextLocalImportAndComplete(nullptr,
true) {
5695 auto *StoredLocs = getTrailingObjects<SourceLocation>();
5696 std::uninitialized_copy(IdentifierLocs.begin(), IdentifierLocs.end(),
5702 :
Decl(
Import, DC, StartLoc), ImportedModule(Imported),
5703 NextLocalImportAndComplete(nullptr,
false) {
5704 *getTrailingObjects<SourceLocation>() = EndLoc;
5711 additionalSizeToAlloc<SourceLocation>(IdentifierLocs.size()))
5712 ImportDecl(DC, StartLoc, Imported, IdentifierLocs);
5719 ImportDecl *Import =
new (
C, DC, additionalSizeToAlloc<SourceLocation>(1))
5721 Import->setImplicit();
5726 unsigned NumLocations) {
5727 return new (
C,
ID, additionalSizeToAlloc<SourceLocation>(NumLocations))
5732 if (!isImportComplete())
5733 return std::nullopt;
5735 const auto *StoredLocs = getTrailingObjects<SourceLocation>();
5741 if (!isImportComplete())
5751void ExportDecl::anchor() {}
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.
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 bool isInNamedModule(const NamedDecl *D)
Determine whether D is attached to a named module.
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.
static bool isFunctionOrMethod(const Decl *D)
isFunctionOrMethod - Return true if the given decl has function type (function or function-typed vari...
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.
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Module * getOwningModuleForLinkage(bool IgnoreLinkage=false) const
Get the module that owns this declaration for linkage purposes.
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.
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 ...
const 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, const 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.
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
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
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.
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.
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member 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.
@ 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.