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));
349 Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl())
354 LV.
merge(getLVForTemplateArgumentList(Arg.getPackAsArray(), computation));
357 llvm_unreachable(
"bad template argument kind");
366 return getLVForTemplateArgumentList(TArgs.
asArray(), computation);
378 return !fn->
hasAttr<VisibilityAttr>();
388void LinkageComputer::mergeTemplateLV(
392 bool considerVisibility =
409 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
462void LinkageComputer::mergeTemplateLV(
485 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
486 if (considerVisibility)
519void LinkageComputer::mergeTemplateLV(
LinkageInfo &LV,
536 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
537 if (considerVisibility)
545 if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden)
548 const auto *FD = dyn_cast<FunctionDecl>(D);
554 = FD->getTemplateSpecializationInfo()) {
557 FD->getMemberSpecializationInfo()) {
558 TSK = MSI->getTemplateSpecializationKind();
571 const T *
First = D->getFirstDecl();
572 return First->isInExternCContext();
576 if (
const auto *SD = dyn_cast<LinkageSpecDecl>(D.
getDeclContext()))
577 if (!SD->hasBraces())
584 return M->isInterfaceOrPartition();
593 if (
auto *TD = dyn_cast<TemplateDecl>(D))
594 D = TD->getTemplatedDecl();
596 if (
auto *VD = dyn_cast<VarDecl>(D))
597 return VD->getStorageClass();
598 if (
auto *FD = dyn_cast<FunctionDecl>(D))
599 return FD->getStorageClass();
605LinkageComputer::getLVForNamespaceScopeDecl(
const NamedDecl *D,
607 bool IgnoreVarTypeLinkage) {
609 "Not a name having namespace scope");
623 if (
const auto *Var = dyn_cast<VarDecl>(D)) {
632 if (Context.
getLangOpts().CPlusPlus && Var->getType().isConstQualified() &&
633 !Var->getType().isVolatileQualified() && !Var->isInline() &&
635 !isa<VarTemplateSpecializationDecl>(Var) &&
636 !Var->getDescribedVarTemplate()) {
641 if (Var->getStorageClass() !=
SC_Extern &&
650 Var->getStorageClass() ==
SC_None)
656 }
else if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(D)) {
658 const VarDecl *VD = IFD->getVarDecl();
659 assert(VD &&
"Expected a VarDecl in this IndirectFieldDecl!");
660 return getLVForNamespaceScopeDecl(VD, computation, IgnoreVarTypeLinkage);
662 assert(!isa<FieldDecl>(D) &&
"Didn't expect a FieldDecl!");
667 const auto *Var = dyn_cast<VarDecl>(D);
668 const auto *
Func = dyn_cast<FunctionDecl>(D);
696 !isa<TranslationUnitDecl>(DC);
698 const auto *ND = dyn_cast<NamespaceDecl>(DC);
700 if (std::optional<Visibility> Vis =
740 if (
const auto *Var = dyn_cast<VarDecl>(D)) {
764 !IgnoreVarTypeLinkage) {
765 LinkageInfo TypeLV = getLVForType(*Var->getType(), computation);
782 if (
const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
783 mergeTemplateLV(LV, spec, computation);
787 }
else if (
const auto *
Function = dyn_cast<FunctionDecl>(D)) {
803 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(
Function)))
819 TypeAsWritten = TSI->getType();
828 =
Function->getTemplateSpecializationInfo()) {
829 mergeTemplateLV(LV,
Function, specInfo, computation);
838 }
else if (
const auto *Tag = dyn_cast<TagDecl>(D)) {
840 if (!Tag->hasNameForLinkage())
846 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
847 mergeTemplateLV(LV, spec, computation);
852 }
else if (isa<EnumConstantDecl>(D)) {
860 }
else if (
const auto *temp = dyn_cast<TemplateDecl>(D)) {
871 }
else if (isa<NamespaceDecl>(D)) {
876 }
else if (isa<ObjCInterfaceDecl>(D)) {
879 }
else if (
auto *TD = dyn_cast<TypedefNameDecl>(D)) {
882 if (!TD->getAnonDeclWithTypedefName(
true))
885 }
else if (isa<MSGuidDecl>(D)) {
903LinkageComputer::getLVForClassMember(
const NamedDecl *D,
905 bool IgnoreVarTypeLinkage) {
916 if (!(isa<CXXMethodDecl>(D) ||
919 isa<IndirectFieldDecl>(D) ||
921 isa<TemplateDecl>(D)))
959 const NamedDecl *explicitSpecSuppressor =
nullptr;
961 if (
const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
964 QualType TypeAsWritten = MD->getType();
966 TypeAsWritten = TSI->getType();
973 = MD->getTemplateSpecializationInfo()) {
974 mergeTemplateLV(LV, MD, spec, computation);
976 explicitSpecSuppressor = MD;
978 explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl();
981 explicitSpecSuppressor = MD;
992 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(MD)))
995 }
else if (
const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
996 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
997 mergeTemplateLV(LV, spec, computation);
999 explicitSpecSuppressor = spec;
1007 explicitSpecSuppressor = RD;
1011 }
else if (
const auto *VD = dyn_cast<VarDecl>(D)) {
1012 if (
const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(VD))
1013 mergeTemplateLV(LV, spec, computation);
1017 if (!IgnoreVarTypeLinkage) {
1027 explicitSpecSuppressor = VD;
1031 }
else if (
const auto *temp = dyn_cast<TemplateDecl>(D)) {
1032 bool considerVisibility =
1040 if (
const auto *redeclTemp = dyn_cast<RedeclarableTemplateDecl>(temp)) {
1048 assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor));
1052 bool considerClassVisibility =
true;
1053 if (explicitSpecSuppressor &&
1058 considerClassVisibility =
false;
1066void NamedDecl::anchor() {}
1089 if (isa<FieldDecl>(
this))
1091 if (
auto *IFD = dyn_cast<IndirectFieldDecl>(
this)) {
1095 VarDecl *VD = IFD->getVarDecl();
1099 if (
const auto *VD = dyn_cast<VarDecl>(
this)) {
1100 if (isa<ParmVarDecl>(VD))
1106 if (
const auto *BD = dyn_cast<BindingDecl>(
this);
1108 VarDecl *VD = BD->getHoldingVar();
1140 if (
auto *VD = dyn_cast<VarDecl>(
this))
1143 if (
auto *FD = dyn_cast<FunctionDecl>(
this))
1144 if (FD->isExternC())
1156 if (name.front() ==
'C')
1157 if (name ==
"CFStringCreateWithFormat" ||
1158 name ==
"CFStringCreateWithFormatAndArguments" ||
1159 name ==
"CFStringAppendFormat" ||
1160 name ==
"CFStringAppendFormatAndArguments")
1176 return M->isNamedModule();
1191 llvm_unreachable(
"unexpected module ownership kind");
1210 !isa<NamespaceDecl>(
this))
1220static std::optional<Visibility>
1223 bool IsMostRecent) {
1232 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
1234 if (InstantiatedFrom)
1241 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
1245 while (TD !=
nullptr) {
1247 if (Vis != std::nullopt)
1249 TD = TD->getPreviousDecl();
1251 return std::nullopt;
1255 if (!IsMostRecent && !isa<NamespaceDecl>(ND)) {
1257 if (MostRecent != ND)
1261 if (
const auto *Var = dyn_cast<VarDecl>(ND)) {
1262 if (Var->isStaticDataMember()) {
1264 if (InstantiatedFrom)
1268 if (
const auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Var))
1269 return getVisibilityOf(VTSD->getSpecializedTemplate()->getTemplatedDecl(),
1272 return std::nullopt;
1275 if (
const auto *fn = dyn_cast<FunctionDecl>(ND)) {
1280 return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(),
1286 if (InstantiatedFrom)
1289 return std::nullopt;
1293 if (
const auto *TD = dyn_cast<TemplateDecl>(ND))
1296 return std::nullopt;
1299std::optional<Visibility>
1310 Owner = dyn_cast<NamedDecl>(DC);
1311 else if (isa<ParmVarDecl>(ContextDecl))
1314 else if (isa<ImplicitConceptSpecializationDecl>(ContextDecl)) {
1319 Owner = cast<NamedDecl>(ContextDecl);
1329 auto *VD = dyn_cast<VarDecl>(Owner);
1345 if (
const auto *
Function = dyn_cast<FunctionDecl>(D)) {
1346 if (
Function->isInAnonymousNamespace() &&
1356 if (std::optional<Visibility> Vis =
1368 if (
const auto *Var = dyn_cast<VarDecl>(D)) {
1369 if (Var->hasExternalStorage()) {
1377 if (std::optional<Visibility> Vis =
1392 if (!Var->isStaticLocal())
1405 if (
const auto *BD = dyn_cast<BlockDecl>(OuterD)) {
1406 if (!BD->getBlockManglingNumber())
1409 LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(),
1410 BD->getBlockManglingContextDecl(), computation);
1412 const auto *FD = cast<FunctionDecl>(OuterD);
1413 if (!FD->isInlined() &&
1423 !Context.
getLangOpts().VisibilityInlinesHiddenStaticLocalVar) {
1424 assert(cast<VarDecl>(D)->isStaticLocal());
1428 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1448 bool IgnoreVarTypeLinkage) {
1450 if (D->
hasAttr<InternalLinkageAttr>())
1465 case Decl::ImplicitParam:
1467 case Decl::NamespaceAlias:
1470 case Decl::UsingEnum:
1471 case Decl::UsingShadow:
1472 case Decl::UsingDirective:
1475 case Decl::EnumConstant:
1482 case Decl::TypeAlias:
1485 if (!cast<TypedefNameDecl>(D)
1486 ->getAnonDeclWithTypedefName(
true))
1490 case Decl::TemplateTemplateParm:
1491 case Decl::NonTypeTemplateParm:
1492 case Decl::ObjCAtDefsField:
1493 case Decl::ObjCCategory:
1494 case Decl::ObjCCategoryImpl:
1495 case Decl::ObjCCompatibleAlias:
1496 case Decl::ObjCImplementation:
1497 case Decl::ObjCMethod:
1498 case Decl::ObjCProperty:
1499 case Decl::ObjCPropertyImpl:
1500 case Decl::ObjCProtocol:
1503 case Decl::CXXRecord: {
1504 const auto *Record = cast<CXXRecordDecl>(D);
1505 if (Record->isLambda()) {
1506 if (Record->hasKnownLambdaInternalLinkage() ||
1507 !Record->getLambdaManglingNumber()) {
1512 return getLVForClosure(
1513 Record->getDeclContext()->getRedeclContext(),
1514 Record->getLambdaContextDecl(), computation);
1520 case Decl::TemplateParamObject: {
1523 auto *TPO = cast<TemplateParamObjectDecl>(D);
1524 LinkageInfo LV = getLVForType(*TPO->getType(), computation);
1525 LV.
merge(getLVForValue(TPO->getValue(), computation));
1532 return getLVForNamespaceScopeDecl(D, computation, IgnoreVarTypeLinkage);
1542 return getLVForClassMember(D, computation, IgnoreVarTypeLinkage);
1556 return getLVForLocalDecl(D, computation);
1567 if (D->
hasAttr<InternalLinkageAttr>())
1573 if (std::optional<LinkageInfo> LI = lookup(D, computation))
1581 cache(D, computation, LV);
1588 if (!Opts.CPlusPlus || Opts.MicrosoftExt)
1595 for (
auto *I : D->
redecls()) {
1596 auto *T = cast<NamedDecl>(I);
1599 if (!T->isInvalidDecl() && T->hasCachedLinkage()) {
1621 if (isa<NamespaceDecl>(
this))
1653 bool InternalLinkage;
1654 if (
auto *ND = dyn_cast<NamedDecl>(
this))
1668 llvm_unreachable(
"unknown module kind");
1672 Name.
print(OS, Policy);
1680 std::string QualName;
1681 llvm::raw_string_ostream OS(QualName);
1704 llvm::raw_svector_ostream NameOS(NameBuffer);
1706 if (NameBuffer.empty())
1707 OS <<
"(anonymous)";
1723 if (
auto *MD = dyn_cast<ObjCMethodDecl>(
this)) {
1724 if (
auto *ID = MD->getClassInterface())
1726 }
else if (
auto *PD = dyn_cast<ObjCPropertyDecl>(
this)) {
1727 if (
auto *MD = PD->getGetterMethodDecl())
1728 if (
auto *ID = MD->getClassInterface())
1730 }
else if (
auto *ID = dyn_cast<ObjCIvarDecl>(
this)) {
1731 if (
auto *CI = ID->getContainingInterface())
1739 ContextsTy Contexts;
1745 if (
P.SuppressUnwrittenScope && isa<NamespaceDecl>(Ctx) &&
1746 cast<NamespaceDecl>(Ctx)->isAnonymousNamespace())
1751 cast<NamespaceDecl>(Ctx)->isRedundantInlineQualifierFor(NameInScope))
1755 const NamedDecl *ND = dyn_cast<NamedDecl>(Ctx);
1759 Contexts.push_back(Ctx);
1763 for (
const DeclContext *DC : llvm::reverse(Contexts)) {
1764 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1765 OS << Spec->getName();
1769 Spec->getSpecializedTemplate()->getTemplateParameters());
1770 }
else if (
const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
1771 if (ND->isAnonymousNamespace()) {
1772 OS << (
P.MSVCFormatting ?
"`anonymous namespace\'"
1773 :
"(anonymous namespace)");
1777 }
else if (
const auto *RD = dyn_cast<RecordDecl>(DC)) {
1778 if (!RD->getIdentifier())
1779 OS <<
"(anonymous " << RD->getKindName() <<
')';
1782 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(DC)) {
1784 if (FD->hasWrittenPrototype())
1785 FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<
FunctionType>());
1789 unsigned NumParams = FD->getNumParams();
1790 for (
unsigned i = 0; i < NumParams; ++i) {
1793 OS << FD->getParamDecl(i)->getType().stream(
P);
1803 }
else if (
const auto *ED = dyn_cast<EnumDecl>(DC)) {
1816 OS << *cast<NamedDecl>(DC);
1837#define DECL(Type, Base) \
1839 return isRedeclarableImpl((Type##Decl *)nullptr);
1840#define ABSTRACT_DECL(DECL)
1841#include "clang/AST/DeclNodes.inc"
1843 llvm_unreachable(
"unknown decl kind");
1859 if (isa<ObjCMethodDecl>(
this))
1864 if (isa<ParmVarDecl>(
this))
1876 if (
auto *UD = dyn_cast<UsingDecl>(
this)) {
1880 cast<UsingDecl>(OldD)->getQualifier());
1882 if (
auto *UUVD = dyn_cast<UnresolvedUsingValueDecl>(
this)) {
1886 cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
1925 llvm_unreachable(
"Linkage hasn't been computed!");
1932 llvm_unreachable(
"Non-formal linkage is not allowed here!");
1937 llvm_unreachable(
"Unhandled Linkage enum");
1940NamedDecl *NamedDecl::getUnderlyingDeclImpl() {
1942 if (
auto *UD = dyn_cast<UsingShadowDecl>(ND))
1943 ND = UD->getTargetDecl();
1945 if (
auto *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND))
1946 return AD->getClassInterface();
1948 if (
auto *AD = dyn_cast<NamespaceAliasDecl>(ND))
1949 return AD->getNamespace();
1959 if (isa<UsingShadowDecl>(D))
1960 D = cast<UsingShadowDecl>(D)->getTargetDecl();
1962 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D))
1964 if (
const auto *MD = dyn_cast_if_present<CXXMethodDecl>(D->
getAsFunction()))
1965 return MD->isInstance();
1973template <
typename DeclT>
1975 if (
decl->getNumTemplateParameterLists() > 0)
1976 return decl->getTemplateParameterList(0)->getTemplateLoc();
1977 return decl->getInnerLocStart();
1995 if (!hasExtInfo()) {
2001 getExtInfo()->TInfo = savedTInfo;
2004 getExtInfo()->QualifierLoc = QualifierLoc;
2005 }
else if (hasExtInfo()) {
2007 getExtInfo()->QualifierLoc = QualifierLoc;
2012 assert(TrailingRequiresClause);
2014 if (!hasExtInfo()) {
2020 getExtInfo()->TInfo = savedTInfo;
2023 getExtInfo()->TrailingRequiresClause = TrailingRequiresClause;
2028 assert(!TPLists.empty());
2030 if (!hasExtInfo()) {
2036 getExtInfo()->TInfo = savedTInfo;
2039 getExtInfo()->setTemplateParameterListsInfo(Context, TPLists);
2057 case Type::BlockPointer:
2060 case Type::MemberPointer:
2063 case Type::LValueReference:
2064 case Type::RValueReference:
2067 case Type::PackExpansion:
2068 QT = cast<PackExpansionType>(T)->getPattern();
2071 case Type::ConstantArray:
2072 case Type::DependentSizedArray:
2073 case Type::IncompleteArray:
2074 case Type::VariableArray:
2075 case Type::FunctionProto:
2076 case Type::FunctionNoProto:
2088 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
2102 if (!TPLists.empty()) {
2123 llvm_unreachable(
"Invalid storage class");
2132 static_assert(
sizeof(VarDeclBitfields) <=
sizeof(
unsigned),
2133 "VarDeclBitfields too large!");
2135 "ParmVarDeclBitfields too large!");
2137 "NonParmVarDeclBitfields too large!");
2146 return new (
C, DC)
VarDecl(Var,
C, DC, StartL, IdL,
Id, T, TInfo, S);
2163 if (!hasAttr<ThreadAttr>() &&
2166 hasAttr<OMPThreadPrivateDeclAttr>()))
2170 hasAttr<OMPThreadPrivateDeclAttr>())
2179 llvm_unreachable(
"Unknown thread storage class specifier!");
2197 if (!D.hasExternalFormalLinkage())
2227 assert(D.getASTContext().getLangOpts().CPlusPlus);
2282 isa<VarTemplatePartialSpecializationDecl>(
this)))
2301 if (
const auto *SAA = getAttr<SelectAnyAttr>())
2302 if (!SAA->isInherited())
2308 if (
auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(
this)) {
2310 !isa<VarTemplatePartialSpecializationDecl>(VTSD) &&
2311 !VTSD->IsCompleteDefinition)
2343 VarDecl *LastTentative =
nullptr;
2348 Kind =
Decl->isThisDeclarationADefinition();
2353 LastTentative =
Decl;
2356 return LastTentative;
2362 if (I->isThisDeclarationADefinition(
C) ==
Definition)
2373 Kind = std::max(
Kind, I->isThisDeclarationADefinition(
C));
2383 if (
auto Expr = I->getInit()) {
2392 if (
auto *
P = dyn_cast<ParmVarDecl>(
this))
2393 if (
P->hasUnparsedDefaultArg() ||
P->hasUninstantiatedDefaultArg())
2396 return !
Init.isNull();
2403 if (
auto *S =
Init.dyn_cast<
Stmt *>())
2404 return cast<Expr>(S);
2407 return cast<Expr>(Eval->Value.isOffset()
2409 : Eval->Value.get(
nullptr));
2414 return ES->Value.getAddressOfPointer(
getASTContext().getExternalSource());
2416 return Init.getAddrOfPtr1();
2425 if (I->isThisDeclarationADefinition()) {
2452 Eval->~EvaluatedStmt();
2464 if (!Lang.CPlusPlus && !Lang.OpenCL)
2468 if (isa<ParmVarDecl>(
this))
2477 if (Lang.CPlusPlus11 &&
getType()->isReferenceType())
2488 if (
getType()->isIntegralOrEnumerationType())
2500 const VarDecl *DefVD =
nullptr;
2502 if (!
Init ||
Init->isValueDependent() ||
getType()->isDependentType())
2548 bool IsConstantInitialization)
const {
2552 assert(!
Init->isValueDependent());
2569 IsConstantInitialization);
2574 if (IsConstantInitialization && Ctx.
getLangOpts().CPlusPlus &&
2602 assert(
Init &&
"no initializer");
2632 "already evaluated var value before checking for constant init");
2635 assert(!
getInit()->isValueDependent());
2639 evaluateValueImpl(Notes,
true) && Notes.empty();
2650 return isa<PackExpansionType>(
getType());
2653template<
typename DeclT>
2656 if (
auto *Def = D->getDefinition())
2672 llvm::any_of(specific_attrs<AlignedAttr>(), [](
const AlignedAttr *AA) {
2673 return AA->isAlignmentDependent();
2692 if (
auto *VDTemplSpec = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2694 auto From = VDTemplSpec->getInstantiatedFrom();
2696 while (!VTD->isMemberSpecialization()) {
2697 auto *NewVTD = VTD->getInstantiatedFromMemberTemplate();
2706 while (!VTPSD->isMemberSpecialization()) {
2707 auto *NewVTPSD = VTPSD->getInstantiatedFromMember();
2712 return getDefinitionOrSelf<VarDecl>(VTPSD);
2720 while (!VarTemplate->isMemberSpecialization()) {
2721 auto *NewVT = VarTemplate->getInstantiatedFromMemberTemplate();
2724 VarTemplate = NewVT;
2737 return cast<VarDecl>(MSI->getInstantiatedFrom());
2743 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2744 return Spec->getSpecializationKind();
2747 return MSI->getTemplateSpecializationKind();
2755 return MSI->getTemplateSpecializationKind();
2757 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2758 return Spec->getSpecializationKind();
2764 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2765 return Spec->getPointOfInstantiation();
2768 return MSI->getPointOfInstantiation();
2791 if (LangOpts.CUDA && !LangOpts.GPURelocatableDeviceCode &&
2793 isa<IncompleteArrayType>(
getType()))
2802 !hasAttr<AlwaysDestroyAttr>()));
2818 assert(
hasInit() &&
"Expect initializer to check for flexible array init");
2820 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2822 auto *
List = dyn_cast<InitListExpr>(
getInit()->IgnoreParens());
2825 const Expr *FlexibleInit =
List->getInit(
List->getNumInits() - 1);
2829 return InitTy->
getSize() != 0;
2833 assert(
hasInit() &&
"Expect initializer to check for flexible array init");
2835 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2837 auto *
List = dyn_cast<InitListExpr>(
getInit()->IgnoreParens());
2840 const Expr *FlexibleInit =
List->getInit(
List->getNumInits() - 1);
2848 if (FlexibleArrayOffset + FlexibleArraySize < RL.
getSize())
2850 return FlexibleArrayOffset + FlexibleArraySize - RL.
getSize();
2864 assert((isa<VarTemplateSpecializationDecl>(
this) ||
2866 "not a variable or static data member template specialization");
2869 dyn_cast<VarTemplateSpecializationDecl>(
this)) {
2870 Spec->setSpecializationKind(TSK);
2872 PointOfInstantiation.
isValid() &&
2873 Spec->getPointOfInstantiation().isInvalid()) {
2874 Spec->setPointOfInstantiation(PointOfInstantiation);
2876 L->InstantiationRequested(
this);
2879 MSI->setTemplateSpecializationKind(TSK);
2881 MSI->getPointOfInstantiation().isInvalid()) {
2882 MSI->setPointOfInstantiation(PointOfInstantiation);
2884 L->InstantiationRequested(
this);
2892 assert(
getASTContext().getTemplateOrSpecializationInfo(
this).isNull() &&
2893 "Previous template or instantiation?");
2906 return new (
C, DC)
ParmVarDecl(ParmVar,
C, DC, StartLoc, IdLoc,
Id, T, TInfo,
2913 if (
const auto *DT = dyn_cast<DecayedType>(T))
2914 return DT->getOriginalType();
2941 if (hasAttr<NSConsumedAttr>())
2947 if (RT && RT->getDecl()->isParamDestroyedInCallee() &&
2957 "Default argument is not yet instantiated!");
2960 if (
auto *E = dyn_cast_if_present<FullExpr>(Arg))
2961 return E->getSubExpr();
2983 return E->getSourceRange();
2988 llvm_unreachable(
"Invalid default argument kind.");
2998 "Wrong kind of initialization expression!");
2999 return cast_if_present<Expr>(
Init.get<
Stmt *>());
3010void ParmVarDecl::setParameterIndexLarge(
unsigned parameterIndex) {
3015unsigned ParmVarDecl::getParameterIndexLarge()
const {
3027 bool UsesFPIntrin,
bool isInlineSpecified,
3029 Expr *TrailingRequiresClause)
3033 EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.
getInfo()) {
3063 if (TrailingRequiresClause)
3076 if (
const auto *FT =
getType()->getAs<FunctionProtoType>())
3077 return FT->isVariadic();
3085 totalSizeToAlloc<DeclAccessPair>(Lookups.size()),
3088 Info->NumLookups = Lookups.size();
3089 std::uninitialized_copy(Lookups.begin(), Lookups.end(),
3096 assert(!
Body &&
"can't replace function body with defaulted function info");
3109 if (I->doesThisDeclarationHaveABody()) {
3126 if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
3139 return InstantiatedFrom->getFriendObjectKind() &&
3140 InstantiatedFrom->isThisDeclarationADefinition();
3147 return InstantiatedFrom->getFriendObjectKind() &&
3148 InstantiatedFrom->isThisDeclarationADefinition();
3155 bool CheckForPendingFriendDefinition)
const {
3157 if (FD->isThisDeclarationADefinition()) {
3177 if (CheckForPendingFriendDefinition &&
3178 FD->isThisDeclarationInstantiatedFromAFriendDefinition()) {
3191 assert(!
Definition->FunctionDeclBits.HasDefaultedFunctionInfo &&
3192 "definition should not have a body");
3210 Parent->markedVirtualFunctionPure();
3213template<std::
size_t Len>
3216 return II && II->
isStr(Str);
3250 if (
const auto *MD = dyn_cast<CXXMethodDecl>(
this);
3251 MD && MD->isLambdaStaticInvoker())
3252 return MD->getParent()->getLambdaCallOperator()->isImmediateFunction();
3282 return llvm::StringSwitch<bool>(
getName())
3295 if (
getDeclName().getCXXOverloadedOperator() != OO_New &&
3296 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3297 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3298 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3305 if (proto->getNumParams() != 2 || proto->isVariadic())
3314 return (proto->getParamType(1).getCanonicalType() == Context.
VoidPtrTy);
3318 std::optional<unsigned> *AlignmentParam,
bool *IsNothrow)
const {
3321 if (
getDeclName().getCXXOverloadedOperator() != OO_New &&
3322 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3323 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3324 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3335 if (FPT->getNumParams() == 0 || FPT->getNumParams() > 4 || FPT->isVariadic())
3340 if (FPT->getNumParams() == 1)
3343 unsigned Params = 1;
3344 QualType Ty = FPT->getParamType(Params);
3347 auto Consume = [&] {
3349 Ty = Params < FPT->getNumParams() ? FPT->getParamType(Params) :
QualType();
3353 bool IsSizedDelete =
false;
3355 (
getDeclName().getCXXOverloadedOperator() == OO_Delete ||
3356 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete) &&
3358 IsSizedDelete =
true;
3367 *AlignmentParam = Params;
3390 T = TD->getDecl()->getUnderlyingType();
3392 if (II && II->
isStr(
"__hot_cold_t"))
3396 return Params == FPT->getNumParams();
3421 llvm_unreachable(
"Unknown GVALinkage");
3435 RD->getIdentifier()->isStr(
"destroying_delete_t");
3447 if (hasAttr<OpenCLKernelAttr>())
3457 if (
const auto *Method = dyn_cast<CXXMethodDecl>(
this))
3458 return Method->isStatic();
3466 if (
const auto *Namespace = cast<NamespaceDecl>(DC)) {
3467 if (!Namespace->getDeclName())
3476 if (hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
3477 hasAttr<C11NoReturnAttr>())
3480 if (
auto *FnTy =
getType()->getAs<FunctionType>())
3481 return FnTy->getNoReturnAttr();
3509 if (hasAttr<TargetAttr>())
3511 if (hasAttr<TargetVersionAttr>())
3513 if (hasAttr<CPUDispatchAttr>())
3515 if (hasAttr<CPUSpecificAttr>())
3517 if (hasAttr<TargetClonesAttr>())
3532 (hasAttr<TargetAttr>() || hasAttr<TargetVersionAttr>());
3546 assert((!PrevDecl || PrevFunTmpl) &&
"Function/function template mismatch");
3547 FunTmpl->setPreviousDecl(PrevFunTmpl);
3570 unsigned BuiltinID = 0;
3572 if (
const auto *ABAA = getAttr<ArmBuiltinAliasAttr>()) {
3573 BuiltinID = ABAA->getBuiltinName()->getBuiltinID();
3574 }
else if (
const auto *BAA = getAttr<BuiltinAliasAttr>()) {
3575 BuiltinID = BAA->getBuiltinName()->getBuiltinID();
3576 }
else if (
const auto *A = getAttr<BuiltinAttr>()) {
3577 BuiltinID = A->getID();
3585 if (!ConsiderWrapperFunctions && hasAttr<OverloadableAttr>() &&
3586 (!hasAttr<ArmBuiltinAliasAttr>() && !hasAttr<BuiltinAliasAttr>()))
3609 if (Context.
getLangOpts().CUDA && hasAttr<CUDADeviceAttr>() &&
3610 !hasAttr<CUDAHostAttr>() &&
3611 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3620 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3636 assert(!ParamInfo &&
"Already has param info!");
3637 assert(NewParamInfo.size() ==
getNumParams() &&
"Parameter count mismatch!");
3640 if (!NewParamInfo.empty()) {
3642 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
3656 unsigned NumRequiredArgs = 0;
3657 unsigned MinParamsSoFar = 0;
3659 if (!Param->isParameterPack()) {
3661 if (!Param->hasDefaultArg())
3662 NumRequiredArgs = MinParamsSoFar;
3665 return NumRequiredArgs;
3695 assert(
isInlined() &&
"expected to get called on an inlined function!");
3699 !hasAttr<DLLExportAttr>())
3704 if (!FD->isImplicit() && FD->getStorageClass() ==
SC_Extern)
3716 if (!FD->isImplicit() && FD->getStorageClass() ==
SC_Extern)
3746 "Must have a declaration without a body.");
3760 if (Context.
getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3770 bool FoundBody =
false;
3795 bool FoundBody =
false;
3820 !
SM.isBeforeInTranslationUnit(RTRange.
getEnd(), Boundary))
3866 hasAttr<AliasAttr>()) &&
3867 "Must be a function definition");
3868 assert(
isInlined() &&
"Function must be inline");
3871 if (Context.
getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3885 for (
auto *Redecl :
redecls()) {
3886 if (Redecl->isInlineSpecified() &&
3896 "should not use C inline rules in C++");
3902 for (
auto *Redecl :
redecls()) {
3931 if (TemplateOrSpecialization.isNull())
3933 if (
const auto *ND = TemplateOrSpecialization.dyn_cast<
NamedDecl *>()) {
3934 if (isa<FunctionDecl>(ND))
3936 assert(isa<FunctionTemplateDecl>(ND) &&
3937 "No other valid types in NamedDecl");
3944 if (TemplateOrSpecialization.is
3948 llvm_unreachable(
"Did we miss a TemplateOrSpecialization type?");
3953 return cast<FunctionDecl>(Info->getInstantiatedFrom());
3962 if (
auto *FTSI = TemplateOrSpecialization
3963 .dyn_cast<FunctionTemplateSpecializationInfo *>())
3964 return FTSI->getMemberSpecializationInfo();
3969FunctionDecl::setInstantiationOfMemberFunction(
ASTContext &
C,
3972 assert(TemplateOrSpecialization.isNull() &&
3973 "Member function is already a specialization");
3976 TemplateOrSpecialization = Info;
3980 return dyn_cast_if_present<FunctionTemplateDecl>(
3981 TemplateOrSpecialization.dyn_cast<
NamedDecl *>());
3986 assert(TemplateOrSpecialization.isNull() &&
3987 "Member function is already a specialization");
3988 TemplateOrSpecialization = Template;
3993 TemplateOrSpecialization
3994 .is<DependentFunctionTemplateSpecializationInfo *>();
3998 assert(TemplateOrSpecialization.isNull() &&
3999 "Function is already a specialization");
4000 TemplateOrSpecialization = FD;
4004 return dyn_cast_if_present<FunctionDecl>(
4005 TemplateOrSpecialization.dyn_cast<
NamedDecl *>());
4029 bool HasPattern =
false;
4031 HasPattern = PatternDecl->
hasBody(PatternDecl);
4037 if (!HasPattern || !PatternDecl)
4061 dyn_cast<CXXMethodDecl>(
this))) {
4073 if (ForDefinition &&
4079 if (ForDefinition &&
4086 while (!ForDefinition || !Primary->isMemberSpecialization()) {
4087 auto *NewPrimary = Primary->getInstantiatedFromMemberTemplate();
4090 Primary = NewPrimary;
4101 = TemplateOrSpecialization
4102 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4103 return Info->getTemplate();
4110 return TemplateOrSpecialization
4117 = TemplateOrSpecialization
4118 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4119 return Info->TemplateArguments;
4127 = TemplateOrSpecialization
4128 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4129 return Info->TemplateArgumentsAsWritten;
4132 TemplateOrSpecialization
4133 .dyn_cast<DependentFunctionTemplateSpecializationInfo *>()) {
4134 return Info->TemplateArgumentsAsWritten;
4140FunctionDecl::setFunctionTemplateSpecialization(
ASTContext &
C,
4147 assert((TemplateOrSpecialization.isNull() ||
4149 "Member function is already a specialization");
4151 "Must specify the type of function template specialization");
4152 assert((TemplateOrSpecialization.isNull() ||
4154 "Member specialization must be an explicit specialization");
4157 C,
this, Template, TSK, TemplateArgs, TemplateArgsAsWritten,
4158 PointOfInstantiation,
4160 TemplateOrSpecialization = Info;
4167 assert(TemplateOrSpecialization.isNull());
4171 TemplateOrSpecialization = Info;
4176 return TemplateOrSpecialization
4184 const auto *TArgsWritten =
4187 totalSizeToAlloc<FunctionTemplateDecl *>(Candidates.
size())))
4191DependentFunctionTemplateSpecializationInfo::
4192 DependentFunctionTemplateSpecializationInfo(
4195 : NumCandidates(Candidates.size()),
4196 TemplateArgumentsAsWritten(TemplateArgsWritten) {
4197 std::transform(Candidates.
begin(), Candidates.
end(),
4198 getTrailingObjects<FunctionTemplateDecl *>(),
4200 return cast<FunctionTemplateDecl>(ND->getUnderlyingDecl());
4208 TemplateOrSpecialization
4209 .dyn_cast<FunctionTemplateSpecializationInfo *>())
4210 return FTSInfo->getTemplateSpecializationKind();
4214 return MSInfo->getTemplateSpecializationKind();
4218 if (TemplateOrSpecialization
4219 .is<DependentFunctionTemplateSpecializationInfo *>() &&
4251 TemplateOrSpecialization
4252 .dyn_cast<FunctionTemplateSpecializationInfo *>()) {
4253 if (
auto *MSInfo = FTSInfo->getMemberSpecializationInfo())
4254 return MSInfo->getTemplateSpecializationKind();
4255 return FTSInfo->getTemplateSpecializationKind();
4260 return MSInfo->getTemplateSpecializationKind();
4262 if (TemplateOrSpecialization
4263 .is<DependentFunctionTemplateSpecializationInfo *>() &&
4274 = TemplateOrSpecialization.dyn_cast<
4276 FTSInfo->setTemplateSpecializationKind(TSK);
4278 PointOfInstantiation.
isValid() &&
4279 FTSInfo->getPointOfInstantiation().isInvalid()) {
4280 FTSInfo->setPointOfInstantiation(PointOfInstantiation);
4282 L->InstantiationRequested(
this);
4286 MSInfo->setTemplateSpecializationKind(TSK);
4288 PointOfInstantiation.
isValid() &&
4289 MSInfo->getPointOfInstantiation().isInvalid()) {
4290 MSInfo->setPointOfInstantiation(PointOfInstantiation);
4292 L->InstantiationRequested(
this);
4295 llvm_unreachable(
"Function cannot have a template specialization kind");
4300 = TemplateOrSpecialization.dyn_cast<
4302 return FTSInfo->getPointOfInstantiation();
4305 return MSInfo->getPointOfInstantiation();
4326 if (FunTmpl->getTemplatedDecl()->hasBody(
Definition))
4345 case Builtin::BI__builtin_memset:
4346 case Builtin::BI__builtin___memset_chk:
4347 case Builtin::BImemset:
4348 return Builtin::BImemset;
4350 case Builtin::BI__builtin_memcpy:
4351 case Builtin::BI__builtin___memcpy_chk:
4352 case Builtin::BImemcpy:
4353 return Builtin::BImemcpy;
4355 case Builtin::BI__builtin_mempcpy:
4356 case Builtin::BI__builtin___mempcpy_chk:
4357 case Builtin::BImempcpy:
4358 return Builtin::BImempcpy;
4360 case Builtin::BI__builtin_memmove:
4361 case Builtin::BI__builtin___memmove_chk:
4362 case Builtin::BImemmove:
4363 return Builtin::BImemmove;
4365 case Builtin::BIstrlcpy:
4366 case Builtin::BI__builtin___strlcpy_chk:
4367 return Builtin::BIstrlcpy;
4369 case Builtin::BIstrlcat:
4370 case Builtin::BI__builtin___strlcat_chk:
4371 return Builtin::BIstrlcat;
4373 case Builtin::BI__builtin_memcmp:
4374 case Builtin::BImemcmp:
4375 return Builtin::BImemcmp;
4377 case Builtin::BI__builtin_bcmp:
4378 case Builtin::BIbcmp:
4379 return Builtin::BIbcmp;
4381 case Builtin::BI__builtin_strncpy:
4382 case Builtin::BI__builtin___strncpy_chk:
4383 case Builtin::BIstrncpy:
4384 return Builtin::BIstrncpy;
4386 case Builtin::BI__builtin_strncmp:
4387 case Builtin::BIstrncmp:
4388 return Builtin::BIstrncmp;
4390 case Builtin::BI__builtin_strncasecmp:
4391 case Builtin::BIstrncasecmp:
4392 return Builtin::BIstrncasecmp;
4394 case Builtin::BI__builtin_strncat:
4395 case Builtin::BI__builtin___strncat_chk:
4396 case Builtin::BIstrncat:
4397 return Builtin::BIstrncat;
4399 case Builtin::BI__builtin_strndup:
4400 case Builtin::BIstrndup:
4401 return Builtin::BIstrndup;
4403 case Builtin::BI__builtin_strlen:
4404 case Builtin::BIstrlen:
4405 return Builtin::BIstrlen;
4407 case Builtin::BI__builtin_bzero:
4408 case Builtin::BIbzero:
4409 return Builtin::BIbzero;
4411 case Builtin::BI__builtin_bcopy:
4412 case Builtin::BIbcopy:
4413 return Builtin::BIbcopy;
4415 case Builtin::BIfree:
4416 return Builtin::BIfree;
4420 if (FnInfo->
isStr(
"memset"))
4421 return Builtin::BImemset;
4422 if (FnInfo->
isStr(
"memcpy"))
4423 return Builtin::BImemcpy;
4424 if (FnInfo->
isStr(
"mempcpy"))
4425 return Builtin::BImempcpy;
4426 if (FnInfo->
isStr(
"memmove"))
4427 return Builtin::BImemmove;
4428 if (FnInfo->
isStr(
"memcmp"))
4429 return Builtin::BImemcmp;
4430 if (FnInfo->
isStr(
"bcmp"))
4431 return Builtin::BIbcmp;
4432 if (FnInfo->
isStr(
"strncpy"))
4433 return Builtin::BIstrncpy;
4434 if (FnInfo->
isStr(
"strncmp"))
4435 return Builtin::BIstrncmp;
4436 if (FnInfo->
isStr(
"strncasecmp"))
4437 return Builtin::BIstrncasecmp;
4438 if (FnInfo->
isStr(
"strncat"))
4439 return Builtin::BIstrncat;
4440 if (FnInfo->
isStr(
"strndup"))
4441 return Builtin::BIstrndup;
4442 if (FnInfo->
isStr(
"strlen"))
4443 return Builtin::BIstrlen;
4444 if (FnInfo->
isStr(
"bzero"))
4445 return Builtin::BIbzero;
4446 if (FnInfo->
isStr(
"bcopy"))
4447 return Builtin::BIbcopy;
4449 if (FnInfo->
isStr(
"free"))
4450 return Builtin::BIfree;
4458 assert(hasODRHash());
4467 setHasODRHash(
true);
4474 setHasODRHash(
true);
4488 return new (
C, DC)
FieldDecl(Decl::Field, DC, StartLoc, IdLoc,
Id, T, TInfo,
4489 BW, Mutable, InitStyle);
4502 if (
const auto *Record =
getType()->getAs<RecordType>())
4503 return Record->getDecl()->isAnonymousStructOrUnion();
4513 return cast_if_present<Expr>(
4515 : InitPtr.
get(
nullptr));
4547 if (!hasAttr<NoUniqueAddressAttr>())
4556 assert(
isInvalidDecl() &&
"valid field has incomplete type");
4562 const auto *CXXRD = cast<CXXRecordDecl>(RD);
4563 if (!CXXRD->isEmpty())
4573 return !llvm::any_of(CXXRD->fields(), [](
const FieldDecl *Field) {
4574 return Field->getType()->getAs<RecordType>();
4584 if (Canonical !=
this)
4587 if (CachedFieldIndex)
return CachedFieldIndex - 1;
4591 assert(RD &&
"requested index for field of struct with no definition");
4593 for (
auto *Field : RD->
fields()) {
4594 Field->getCanonicalDecl()->CachedFieldIndex = Index + 1;
4595 assert(Field->getCanonicalDecl()->CachedFieldIndex == Index + 1 &&
4596 "overflow in field numbering");
4600 assert(CachedFieldIndex &&
"failed to find field in parent");
4601 return CachedFieldIndex - 1;
4615 "capturing type in non-lambda or captured record.");
4616 assert(StorageKind == ISK_NoInit && !BitField &&
4617 "bit-field or field with default member initializer cannot capture "
4619 StorageKind = ISK_CapturedVLAType;
4643 "EnumDecl not matched with TagTypeKind::Enum");
4651 TagDeclBits.IsThisDeclarationADemotedDefinition =
false;
4667 TypedefNameDeclOrQualifier = TDD;
4678 if (
auto *D = dyn_cast<CXXRecordDecl>(
this)) {
4679 struct CXXRecordDecl::DefinitionData *
Data =
4680 new (
getASTContext())
struct CXXRecordDecl::DefinitionData(D);
4682 cast<CXXRecordDecl>(I)->DefinitionData =
Data;
4687 assert((!isa<CXXRecordDecl>(
this) ||
4689 "definition completed but not started");
4695 L->CompletedTagDefinition(
this);
4700 return const_cast<TagDecl *
>(
this);
4705 if (II->isOutOfDate()) {
4711 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(
this))
4712 return CXXRD->getDefinition();
4715 if (R->isCompleteDefinition())
4731 if (getExtInfo()->NumTemplParamLists == 0) {
4745 if (Name.isIdentifier() && !Name.getAsIdentifierInfo()) {
4750 Copy.SuppressScope =
true;
4755 Name.print(OS, Policy);
4760 assert(!TPLists.empty());
4775 bool Scoped,
bool ScopedUsingClassTag,
bool Fixed)
4777 assert(Scoped || !ScopedUsingClassTag);
4778 IntegerType =
nullptr;
4779 setNumPositiveBits(0);
4780 setNumNegativeBits(0);
4782 setScopedUsingClassTag(ScopedUsingClassTag);
4784 setHasODRHash(
false);
4788void EnumDecl::anchor() {}
4794 bool IsScopedUsingClassTag,
bool IsFixed) {
4796 IsScoped, IsScopedUsingClassTag, IsFixed);
4797 Enum->setMayHaveOutOfDateDef(
C.getLangOpts().Modules);
4798 C.getTypeDeclType(
Enum, PrevDecl);
4805 nullptr,
nullptr,
false,
false,
false);
4806 Enum->setMayHaveOutOfDateDef(
C.getLangOpts().Modules);
4812 return TI->getTypeLoc().getSourceRange();
4818 unsigned NumPositiveBits,
4819 unsigned NumNegativeBits) {
4823 PromotionType = NewPromotionType;
4824 setNumPositiveBits(NumPositiveBits);
4825 setNumNegativeBits(NumNegativeBits);
4830 if (
const auto *A = getAttr<EnumExtensibilityAttr>())
4831 return A->getExtensibility() == EnumExtensibilityAttr::Closed;
4836 return isClosed() && hasAttr<FlagEnumAttr>();
4840 return isClosed() && !hasAttr<FlagEnumAttr>();
4845 return MSI->getTemplateSpecializationKind();
4853 assert(MSI &&
"Not an instantiated member enumeration?");
4856 PointOfInstantiation.
isValid() &&
4872 "couldn't find pattern for enum instantiation");
4877 if (SpecializationInfo)
4885 assert(!SpecializationInfo &&
"Member enum is already a specialization");
4895 setHasODRHash(
true);
4906 Res.setEnd(TSI->getTypeLoc().getEndLoc());
4916 if (NumNegativeBits) {
4917 unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1);
4918 Max = llvm::APInt(Bitwidth, 1) << (NumBits - 1);
4921 Max = llvm::APInt(Bitwidth, 1) << NumPositiveBits;
4922 Min = llvm::APInt::getZero(Bitwidth);
4934 :
TagDecl(DK, TK,
C, DC, IdLoc,
Id, PrevDecl, StartLoc) {
4935 assert(
classof(
static_cast<Decl *
>(
this)) &&
"Invalid Kind!");
4957 StartLoc, IdLoc,
Id, PrevDecl);
4960 C.getTypeDeclType(R, PrevDecl);
4978 if (
auto RD = dyn_cast<CXXRecordDecl>(
this))
4979 return RD->isLambda();
4984 return hasAttr<CapturedRecordAttr>();
4996 for (
const FieldDecl *FD : Def->fields()) {
5008 LoadFieldsFromExternalStorage();
5012 return D->field_begin();
5034 return hasAttr<MSStructAttr>() ||
C.getLangOpts().MSBitfields == 1;