37#include "llvm/Support/TimeProfiler.h"
48 return cast<CXXRecordDecl>(DC)->isLocalClass();
53template<
typename DeclT>
56 if (!OldDecl->getQualifierLoc())
59 assert((NewDecl->getFriendObjectKind() ||
60 !OldDecl->getLexicalDeclContext()->isDependentContext()) &&
61 "non-friend with qualified name defined in dependent context");
64 const_cast<DeclContext *
>(NewDecl->getFriendObjectKind()
65 ? NewDecl->getLexicalDeclContext()
66 : OldDecl->getLexicalDeclContext()));
75 NewDecl->setQualifierInfo(NewQualifierLoc);
81 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
86 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
90#include "clang/Sema/AttrTemplateInstantiate.inc"
94 const AlignedAttr *Aligned,
Decl *New,
bool IsPackExpansion) {
95 if (Aligned->isAlignmentExpr()) {
104 S.
SubstType(Aligned->getAlignmentType(), TemplateArgs,
107 Aligned->getLocation(),
108 Result->getTypeLoc().getSourceRange()))
116 const AlignedAttr *Aligned,
Decl *New) {
117 if (!Aligned->isPackExpansion()) {
123 if (Aligned->isAlignmentExpr())
129 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
132 bool Expand =
true, RetainExpansion =
false;
133 std::optional<unsigned> NumExpansions;
137 Unexpanded, TemplateArgs, Expand,
138 RetainExpansion, NumExpansions))
145 for (
unsigned I = 0; I != *NumExpansions; ++I) {
154 const AssumeAlignedAttr *Aligned,
Decl *New) {
159 Expr *
E, *OE =
nullptr;
165 if (Aligned->getOffset()) {
177 const AlignValueAttr *Aligned,
Decl *New) {
188 const AllocAlignAttr *Align,
Decl *New) {
191 llvm::APInt(64, Align->getParamIndex().getSourceIndex()),
198 const AnnotateAttr *
Attr,
Decl *New) {
204 bool HasDelayedArgs =
Attr->delayedArgs_size();
213 false, TemplateArgs, Args))
216 StringRef Str =
Attr->getAnnotation();
217 if (HasDelayedArgs) {
218 if (Args.size() < 1) {
228 ActualArgs.insert(ActualArgs.begin(), Args.begin() + 1, Args.end());
229 std::swap(Args, ActualArgs);
237 Expr *Cond =
nullptr;
251 Cond = Converted.
get();
257 S.
Diag(A->
getLocation(), diag::err_attr_cond_never_constant_expr) << A;
258 for (
const auto &
P : Diags)
259 S.
Diag(
P.first,
P.second);
269 S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);
273 Cond, EIA->getMessage()));
280 S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);
285 DIA->getDiagnosticType(), DIA->getArgDependent(), New));
292 const CUDALaunchBoundsAttr &
Attr,
Decl *New) {
302 Expr *MinBlocks =
nullptr;
303 if (
Attr.getMinBlocks()) {
310 Expr *MaxBlocks =
nullptr;
311 if (
Attr.getMaxBlocks()) {
332 const OMPDeclareSimdDeclAttr &
Attr,
Decl *New) {
334 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
335 New = FTD->getTemplatedDecl();
336 auto *FD = cast<FunctionDecl>(New);
337 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
343 if (
auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
346 if (FD->getNumParams() > PVD->getFunctionScopeIndex())
347 Local.InstantiatedLocal(
348 PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
352 FD->isCXXInstanceMember());
368 if (
auto *
E =
Attr.getSimdlen())
371 if (
Attr.uniforms_size() > 0) {
372 for(
auto *
E :
Attr.uniforms()) {
376 Uniforms.push_back(Inst.
get());
380 auto AI =
Attr.alignments_begin();
381 for (
auto *
E :
Attr.aligneds()) {
385 Aligneds.push_back(Inst.
get());
389 Alignments.push_back(Inst.
get());
393 auto SI =
Attr.steps_begin();
394 for (
auto *
E :
Attr.linears()) {
398 Linears.push_back(Inst.
get());
402 Steps.push_back(Inst.
get());
405 LinModifiers.append(
Attr.modifiers_begin(),
Attr.modifiers_end());
408 Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps,
415 const OMPDeclareVariantAttr &
Attr,
Decl *New) {
417 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
418 New = FTD->getTemplatedDecl();
419 auto *FD = cast<FunctionDecl>(New);
420 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
422 auto &&SubstExpr = [FD, ThisContext, &S, &TemplateArgs](
Expr *
E) {
424 if (
auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
427 if (FD->getNumParams() > PVD->getFunctionScopeIndex())
428 Local.InstantiatedLocal(
429 PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
433 FD->isCXXInstanceMember());
439 auto &&Subst = [&SubstExpr, &S](
Expr *
E) {
449 if (
Expr *
E =
Attr.getVariantFuncRef()) {
454 VariantFuncRef = Subst(
E);
460 TI = *
Attr.getTraitInfos();
463 auto SubstScoreOrConditionExpr = [&S, Subst](
Expr *&
E,
bool) {
482 std::optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
490 E = DeclVarData->second;
491 FD = DeclVarData->first;
494 if (
auto *VariantFD = dyn_cast<FunctionDecl>(VariantDRE->getDecl())) {
495 if (
auto *VariantFTD = VariantFD->getDescribedFunctionTemplate()) {
496 if (!VariantFTD->isThisDeclarationADefinition())
507 SubstFD->getType(), FD->getType(),
515 SubstFD->setInstantiationIsPending(!SubstFD->isDefined());
519 SubstFD->getLocation(),
529 for (
Expr *
E :
Attr.adjustArgsNothing()) {
533 NothingExprs.push_back(ER.
get());
535 for (
Expr *
E :
Attr.adjustArgsNeedDevicePtr()) {
539 NeedDevicePtrExprs.push_back(ER.
get());
543 AppendArgs.emplace_back(II.IsTarget, II.IsTargetSync);
547 FD,
E, TI, NothingExprs, NeedDevicePtrExprs, AppendArgs,
SourceLocation(),
553 const AMDGPUFlatWorkGroupSizeAttr &
Attr,
Decl *New) {
576 Expr *Cond =
nullptr;
584 Cond = SubstResult.
get();
594 const AMDGPUWavesPerEUAttr &
Attr,
Decl *New) {
604 Expr *MaxExpr =
nullptr;
605 if (
auto Max =
Attr.getMax()) {
617 const AMDGPUMaxNumWorkGroupsAttr &
Attr,
Decl *New) {
643 const SYCLKernelAttr &
Attr,
Decl *New) {
653 if (
const auto *PNA = dyn_cast<PreferredNameAttr>(A)) {
655 const auto *RD = cast<CXXRecordDecl>(
D);
661 PNA->getTypedefType()))
666 if (
const auto *BA = dyn_cast<BuiltinAttr>(A)) {
668 switch (BA->getID()) {
669 case Builtin::BIforward:
679 case Builtin::BImove:
680 case Builtin::BImove_if_noexcept:
696 const HLSLParamModifierAttr *
Attr,
Decl *New) {
706 if (
NamedDecl *ND = dyn_cast<NamedDecl>(New)) {
710 for (
const auto *TmplAttr : Tmpl->
attrs()) {
717 *
this, dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()),
721 TmplAttr,
Context, *
this, TemplateArgs);
731 case clang::attr::CFConsumed:
733 case clang::attr::OSConsumed:
735 case clang::attr::NSConsumed:
738 llvm_unreachable(
"Wrong argument supplied");
746 for (
const auto *TmplAttr : Tmpl->
attrs()) {
751 const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
752 if (Aligned && Aligned->isAlignmentDependent()) {
757 if (
const auto *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr)) {
762 if (
const auto *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr)) {
767 if (
const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) {
772 if (
const auto *Annotate = dyn_cast<AnnotateAttr>(TmplAttr)) {
777 if (
const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
779 cast<FunctionDecl>(New));
783 if (
const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
785 cast<FunctionDecl>(New));
789 if (
const auto *CUDALaunchBounds =
790 dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
792 *CUDALaunchBounds, New);
796 if (
const auto *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
801 if (
const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
806 if (
const auto *OMPAttr = dyn_cast<OMPDeclareVariantAttr>(TmplAttr)) {
811 if (
const auto *AMDGPUFlatWorkGroupSize =
812 dyn_cast<AMDGPUFlatWorkGroupSizeAttr>(TmplAttr)) {
814 *
this, TemplateArgs, *AMDGPUFlatWorkGroupSize, New);
817 if (
const auto *AMDGPUFlatWorkGroupSize =
818 dyn_cast<AMDGPUWavesPerEUAttr>(TmplAttr)) {
820 *AMDGPUFlatWorkGroupSize, New);
823 if (
const auto *AMDGPUMaxNumWorkGroups =
824 dyn_cast<AMDGPUMaxNumWorkGroupsAttr>(TmplAttr)) {
826 *
this, TemplateArgs, *AMDGPUMaxNumWorkGroups, New);
829 if (
const auto *ParamAttr = dyn_cast<HLSLParamModifierAttr>(TmplAttr)) {
836 if (TmplAttr->getKind() == attr::DLLExport ||
837 TmplAttr->getKind() == attr::DLLImport) {
838 if (New->
hasAttr<DLLExportAttr>() || New->
hasAttr<DLLImportAttr>()) {
843 if (
const auto *ABIAttr = dyn_cast<ParameterABIAttr>(TmplAttr)) {
848 if (isa<NSConsumedAttr>(TmplAttr) || isa<OSConsumedAttr>(TmplAttr) ||
849 isa<CFConsumedAttr>(TmplAttr)) {
856 if (
auto *A = dyn_cast<PointerAttr>(TmplAttr)) {
857 if (!New->
hasAttr<PointerAttr>())
862 if (
auto *A = dyn_cast<OwnerAttr>(TmplAttr)) {
863 if (!New->
hasAttr<OwnerAttr>())
868 if (
auto *A = dyn_cast<SYCLKernelAttr>(TmplAttr)) {
873 assert(!TmplAttr->isPackExpansion());
874 if (TmplAttr->isLateParsed() && LateAttrs) {
883 auto *ND = cast<NamedDecl>(New);
884 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
886 ND->isCXXInstanceMember());
889 *
this, TemplateArgs);
897 for (
const auto *
Attr : Pattern->
attrs()) {
898 if (
auto *A = dyn_cast<StrictFPAttr>(
Attr)) {
899 if (!Inst->
hasAttr<StrictFPAttr>())
912 DLLExportAttr *
Attr = Ctor->
getAttr<DLLExportAttr>();
915 for (
unsigned I = 0; I != NumParams; ++I) {
926template<
typename DeclT>
942 llvm_unreachable(
"Translation units cannot be instantiated");
946 llvm_unreachable(
"HLSL buffer declarations cannot be instantiated");
951 llvm_unreachable(
"pragma comment cannot be instantiated");
954Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl(
956 llvm_unreachable(
"pragma comment cannot be instantiated");
961 llvm_unreachable(
"extern \"C\" context cannot be instantiated");
965 llvm_unreachable(
"GUID declaration cannot be instantiated");
968Decl *TemplateDeclInstantiator::VisitUnnamedGlobalConstantDecl(
970 llvm_unreachable(
"UnnamedGlobalConstantDecl cannot be instantiated");
973Decl *TemplateDeclInstantiator::VisitTemplateParamObjectDecl(
975 llvm_unreachable(
"template parameter objects cannot be instantiated");
979TemplateDeclInstantiator::VisitLabelDecl(
LabelDecl *
D) {
988 llvm_unreachable(
"Namespaces cannot be instantiated");
995 D->getNamespaceLoc(),
998 D->getQualifierLoc(),
999 D->getTargetNameLoc(),
1011 DI = SemaRef.
SubstType(DI, TemplateArgs,
1032 D->getIdentifier() &&
D->getIdentifier()->isStr(
"type") &&
1051 if (
const TagType *oldTagType =
D->getUnderlyingType()->getAs<
TagType>()) {
1052 TagDecl *oldTag = oldTagType->getDecl();
1122 if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
1124 if (!
Found.empty()) {
1125 PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(
Found.front());
1136 D->getDeclName(), InstParams, AliasInst);
1138 if (PrevAliasTemplate)
1143 if (!PrevAliasTemplate)
1160 D->getIdentifier());
1169 for (
auto *OldBD :
D->bindings())
1170 NewBindings.push_back(cast<BindingDecl>(VisitBindingDecl(OldBD)));
1173 auto *NewDD = cast_or_null<DecompositionDecl>(
1176 if (!NewDD || NewDD->isInvalidDecl())
1177 for (
auto *NewBD : NewBindings)
1178 NewBD->setInvalidDecl();
1188 bool InstantiatingVarTemplate,
1193 D->getTypeSourceInfo(), TemplateArgs,
D->getTypeSpecStartLoc(),
1194 D->getDeclName(),
true);
1199 SemaRef.
Diag(
D->
getLocation(), diag::err_variable_instantiates_to_function)
1200 <<
D->isStaticDataMember() << DI->
getType();
1217 DI,
D->getStorageClass());
1232 StartingScope, InstantiatingVarTemplate);
1235 if (
auto *F = dyn_cast<FunctionDecl>(DC))
1236 RT = F->getReturnType();
1237 else if (isa<BlockDecl>(DC))
1241 llvm_unreachable(
"Unknown context type");
1273 D->getAccessSpecifierLoc(),
D->getColonLoc());
1283 DI = SemaRef.
SubstType(DI, TemplateArgs,
1286 DI =
D->getTypeSourceInfo();
1303 Expr *BitWidth =
D->getBitWidth();
1306 else if (BitWidth) {
1312 = SemaRef.
SubstExpr(BitWidth, TemplateArgs);
1317 BitWidth = InstantiatedBitWidth.
getAs<
Expr>();
1322 cast<RecordDecl>(Owner),
1326 D->getInClassInitStyle(),
1327 D->getInnerLocStart(),
1337 if (
Field->hasAttrs())
1341 Field->setInvalidDecl();
1343 if (!
Field->getDeclName()) {
1348 if (
Parent->isAnonymousStructOrUnion() &&
1349 Parent->getRedeclContext()->isFunctionOrMethod())
1369 DI = SemaRef.
SubstType(DI, TemplateArgs,
1372 DI =
D->getTypeSourceInfo();
1410 for (
auto *PI :
D->chain()) {
1416 NamedChain[i++] = Next;
1419 QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
1422 {NamedChain, D->getChainingSize()});
1429 Owner->
addDecl(IndirectField);
1430 return IndirectField;
1442 if (
D->isUnsupportedFriend()) {
1445 InstTy = SemaRef.
SubstType(Ty, TemplateArgs,
1460 assert(ND &&
"friend decl must be a decl or a type!");
1467 if (!NewND)
return nullptr;
1471 cast<NamedDecl>(NewND),
D->getFriendLoc());
1479 Expr *AssertExpr =
D->getAssertExpr();
1486 = SemaRef.
SubstExpr(AssertExpr, TemplateArgs);
1491 SemaRef.
SubstExpr(
D->getMessage(), TemplateArgs);
1492 if (InstantiatedMessageExpr.
isInvalid())
1497 InstantiatedMessageExpr.
get(),
D->getRParenLoc(),
D->isFailed());
1506 if (!Prev)
return nullptr;
1507 PrevDecl = cast<EnumDecl>(Prev);
1513 D->isScoped(),
D->isScopedUsingClassTag(),
D->isFixed());
1525 Enum->setIntegerTypeSourceInfo(NewTI);
1527 assert(!
D->getIntegerType()->isDependentType()
1528 &&
"Dependent type without type source info");
1529 Enum->setIntegerType(
D->getIntegerType());
1551 if (Def && Def !=
D) {
1558 SemaRef.
SubstType(TI->getType(), TemplateArgs,
1561 DefnUnderlying,
true,
Enum);
1582 Enum->startDefinition();
1593 if (
Expr *UninstValue = EC->getInitExpr()) {
1603 if (
Value.isInvalid()) {
1616 Enum->setInvalidDecl();
1623 Enum->addDecl(EnumConst);
1624 Enumerators.push_back(EnumConst);
1625 LastEnumConst = EnumConst;
1628 !
Enum->isScoped()) {
1641 llvm_unreachable(
"EnumConstantDecls can only occur within EnumDecls.");
1646 llvm_unreachable(
"BuiltinTemplateDecls cannot be instantiated.");
1678 if (!
Found.empty()) {
1679 PrevClassTemplate = dyn_cast<ClassTemplateDecl>(
Found.front());
1680 if (PrevClassTemplate)
1693 SS.
Adopt(QualifierLoc);
1695 if (!DC)
return nullptr;
1709 if (R.isSingleResult()) {
1711 if (PrevClassTemplate)
1715 if (!PrevClassTemplate && QualifierLoc) {
1717 << llvm::to_underlying(
D->getTemplatedDecl()->getTagKind())
1735 D->getIdentifier(), InstParams, RecordInst);
1744 if (PrevClassTemplate) {
1775 if (!PrevClassTemplate)
1798 if (!PrevClassTemplate) {
1803 D->getPartialSpecializations(PartialSpecs);
1804 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1805 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1806 OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
1813TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
1825 = dyn_cast<ClassTemplateDecl>(
Found.front());
1826 if (!InstClassTemplate)
1837 assert(
D->getTemplatedDecl()->isStaticDataMember() &&
1838 "Only static data member templates are allowed.");
1848 VarDecl *Pattern =
D->getTemplatedDecl();
1854 PrevVarTemplate = dyn_cast<VarTemplateDecl>(
Found.front());
1860 if (!VarInst)
return nullptr;
1871 if (!PrevVarTemplate)
1881 if (!PrevVarTemplate) {
1886 D->getPartialSpecializations(PartialSpecs);
1887 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1888 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1889 OutOfLineVarPartialSpecs.push_back(
1890 std::make_pair(Inst, PartialSpecs[I]));
1896Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
1898 assert(
D->isStaticDataMember() &&
1899 "Only static data member templates are allowed.");
1905 assert(!
Found.empty() &&
"Instantiation found nothing?");
1908 assert(InstVarTemplate &&
"Instantiation did not find a variable template?");
1932 if (
CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(
D->getTemplatedDecl()))
1937 D->getTemplatedDecl(),
1948 assert(InstTemplate &&
1949 "VisitFunctionDecl/CXXMethodDecl didn't create a template!");
1956 !(isFriend && !
D->getTemplatedDecl()->isThisDeclarationADefinition()))
1967 return InstTemplate;
1976 if (!Prev)
return nullptr;
1977 PrevDecl = cast<CXXRecordDecl>(Prev);
1981 bool IsInjectedClassName =
D->isInjectedClassName();
1985 D->getLambdaDependencyKind(),
D->isGenericLambda(),
1986 D->getLambdaCaptureDefault());
1990 D->getIdentifier(), PrevDecl,
1991 IsInjectedClassName);
1993 if (IsInjectedClassName)
2009 if (!IsInjectedClassName)
2015 Record->setObjectOfFriendDecl();
2018 if (
D->isAnonymousStructOrUnion())
2019 Record->setAnonymousStructOrUnion(
true);
2021 if (
D->isLocalClass())
2042 if (
D->isCompleteDefinition() &&
D->isLocalClass()) {
2051 if (!
D->isCXXClassMember())
2057 LocalInstantiations.perform();
2062 if (IsInjectedClassName)
2063 assert(
Record->isInjectedClassName() &&
"Broken injected-class-name");
2081 if (OrigFunc->
getExtInfo() == NewFunc->getExtInfo())
2087 NewFunc->getParamTypes(), NewEPI);
2101 if (FunctionTemplate && !TemplateParams) {
2104 void *InsertPos =
nullptr;
2114 if (FunctionTemplate)
2119 bool MergeWithParentScope = (TemplateParams !=
nullptr) ||
2121 !(isa<Decl>(Owner) &&
2122 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
2126 if (
auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(
D)) {
2128 TemplateArgs, DGuide->getExplicitSpecifier());
2129 if (InstantiatedExplicitSpecifier.
isInvalid())
2139 if (TemplateParams && TemplateParams->
size()) {
2141 dyn_cast<TemplateTypeParmDecl>(TemplateParams->
asArray().back());
2142 if (LastParam && LastParam->isImplicit() &&
2143 LastParam->hasTypeConstraint()) {
2164 Expr *TrailingRequiresClause =
D->getTrailingRequiresClause();
2173 }
else if (isFriend && QualifierLoc) {
2175 SS.
Adopt(QualifierLoc);
2177 if (!DC)
return nullptr;
2190 if (
auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(
D)) {
2192 SemaRef.
Context, DC,
D->getInnerLocStart(),
2193 InstantiatedExplicitSpecifier, NameInfo,
T, TInfo,
2195 DGuide->getDeductionCandidateKind());
2199 SemaRef.
Context, DC,
D->getInnerLocStart(), NameInfo,
T, TInfo,
2201 D->isInlineSpecified(),
D->hasWrittenPrototype(),
D->getConstexprKind(),
2202 TrailingRequiresClause);
2203 Function->setFriendConstraintRefersToEnclosingTemplate(
2204 D->FriendConstraintRefersToEnclosingTemplate());
2212 Function->setQualifierInfo(QualifierLoc);
2226 Function->setLexicalDeclContext(LexicalDC);
2229 for (
unsigned P = 0;
P < Params.size(); ++
P)
2234 if (TrailingRequiresClause)
2235 Function->setTrailingRequiresClause(TrailingRequiresClause);
2237 if (TemplateParams) {
2256 Function->setDescribedFunctionTemplate(FunctionTemplate);
2260 if (isFriend &&
D->isThisDeclarationADefinition()) {
2262 D->getDescribedFunctionTemplate());
2264 }
else if (FunctionTemplate &&
2269 Function->setFunctionTemplateSpecialization(FunctionTemplate,
2274 if (isFriend &&
D->isThisDeclarationADefinition()) {
2279 }
else if (!isFriend) {
2290 FT->setObjectOfFriendDecl();
2296 bool IsExplicitSpecialization =
false;
2306 D->getDependentSpecializationInfo()) {
2307 assert(isFriend &&
"dependent specialization info on "
2308 "non-member non-friend function?");
2312 if (
const auto *ArgsWritten = DFTSI->TemplateArgumentsAsWritten) {
2313 ExplicitArgs.
setLAngleLoc(ArgsWritten->getLAngleLoc());
2314 ExplicitArgs.
setRAngleLoc(ArgsWritten->getRAngleLoc());
2331 DFTSI->TemplateArgumentsAsWritten ? &ExplicitArgs :
nullptr,
2335 IsExplicitSpecialization =
true;
2337 D->getTemplateSpecializationArgsAsWritten()) {
2343 ArgsWritten->getRAngleLoc());
2353 IsExplicitSpecialization =
true;
2354 }
else if (TemplateParams || !FunctionTemplate) {
2370 if (isFriend && !QualifierLoc) {
2390 if (
Function->isLocalExternDecl()) {
2392 if (!PVD->hasDefaultArg())
2398 Expr *UninstExpr = PVD->getUninstantiatedDefaultArg();
2401 { UninstExpr }, UninstExpr->
getType());
2403 PVD->setDefaultArg(ErrorResult.
get());
2409 IsExplicitSpecialization,
2410 Function->isThisDeclarationADefinition());
2416 if (isFriend && TemplateParams && FunctionTemplate->
getPreviousDecl()) {
2420 Function->isThisDeclarationADefinition()
2429 if (isFriend &&
D->isThisDeclarationADefinition() &&
Function->isUsed(
false)) {
2431 Function->getMemberSpecializationInfo()) {
2432 if (MSInfo->getPointOfInstantiation().isInvalid()) {
2434 MSInfo->setPointOfInstantiation(
Loc);
2441 if (
D->isExplicitlyDefaulted()) {
2449 (TemplateParams ? cast<NamedDecl>(FunctionTemplate) :
Function);
2468 if (FunctionTemplate && !TemplateParams) {
2474 void *InsertPos =
nullptr;
2484 if (FunctionTemplate)
2489 bool MergeWithParentScope = (TemplateParams !=
nullptr) ||
2490 !(isa<Decl>(Owner) &&
2491 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
2499 unsigned NumTempParamLists = 0;
2500 if (isFriend && (NumTempParamLists =
D->getNumTemplateParameterLists())) {
2501 TempParamLists.resize(NumTempParamLists);
2502 for (
unsigned I = 0; I != NumTempParamLists; ++I) {
2507 TempParamLists[I] = InstParams;
2513 const bool CouldInstantiate =
2514 InstantiatedExplicitSpecifier.getExpr() ==
nullptr ||
2515 !InstantiatedExplicitSpecifier.getExpr()->isValueDependent();
2519 if (CouldInstantiate ||
2523 TemplateArgs, InstantiatedExplicitSpecifier);
2525 if (InstantiatedExplicitSpecifier.isInvalid())
2537 if (cast<CXXRecordDecl>(
D->getParent())->isLambda() &&
2538 !
D->getTypeSourceInfo() &&
2539 isa<CXXConstructorDecl, CXXDestructorDecl>(
D)) {
2542 D->setTypeSourceInfo(TSI);
2551 if (TemplateParams && TemplateParams->
size()) {
2553 dyn_cast<TemplateTypeParmDecl>(TemplateParams->
asArray().back());
2554 if (LastParam && LastParam->isImplicit() &&
2555 LastParam->hasTypeConstraint()) {
2580 SS.
Adopt(QualifierLoc);
2590 if (!DC)
return nullptr;
2594 Expr *TrailingRequiresClause =
D->getTrailingRequiresClause();
2609 InstantiatedExplicitSpecifier, Constructor->UsesFPIntrin(),
2610 Constructor->isInlineSpecified(),
false,
2612 TrailingRequiresClause);
2618 Destructor->getConstexprKind(), TrailingRequiresClause);
2627 Conversion->UsesFPIntrin(), Conversion->isInlineSpecified(),
2628 InstantiatedExplicitSpecifier, Conversion->getConstexprKind(),
2629 Conversion->getEndLoc(), TrailingRequiresClause);
2634 D->UsesFPIntrin(),
D->isInlineSpecified(),
D->getConstexprKind(),
2644 if (TemplateParams) {
2661 TemplateParams, Method);
2668 }
else if (FunctionTemplate) {
2684 if (NumTempParamLists)
2695 for (
unsigned P = 0;
P < Params.size(); ++
P)
2696 Params[
P]->setOwningFunction(Method);
2703 RedeclarationKind::ForExternalRedeclaration);
2705 bool IsExplicitSpecialization =
false;
2710 D->getDependentSpecializationInfo()) {
2713 if (
const auto *ArgsWritten = DFTSI->TemplateArgumentsAsWritten) {
2714 ExplicitArgs.
setLAngleLoc(ArgsWritten->getLAngleLoc());
2715 ExplicitArgs.
setRAngleLoc(ArgsWritten->getRAngleLoc());
2731 Method, DFTSI->TemplateArgumentsAsWritten ? &ExplicitArgs :
nullptr,
2735 IsExplicitSpecialization =
true;
2737 D->getTemplateSpecializationArgsAsWritten()) {
2741 ArgsWritten->getRAngleLoc());
2752 IsExplicitSpecialization =
true;
2753 }
else if (!FunctionTemplate || TemplateParams || isFriend) {
2780 for (
unsigned P = 0;
P < Params.size(); ++
P) {
2781 if (!Params[
P]->hasDefaultArg())
2787 Expr *UninstExpr = Params[
P]->getUninstantiatedDefaultArg();
2790 { UninstExpr }, UninstExpr->
getType());
2792 Params[
P]->setDefaultArg(ErrorResult.
get());
2798 IsExplicitSpecialization,
2801 if (
D->isPureVirtual())
2811 if (FunctionTemplate)
2817 if (
D->isExplicitlyDefaulted()) {
2821 if (
D->isDeletedAsWritten())
2823 D->getDeletedMessage());
2828 if (IsExplicitSpecialization && !isFriend)
2838 if (
auto *Constructor = dyn_cast<CXXConstructorDecl>(Method)) {
2839 if (Constructor->isDefaultConstructor() ||
2840 Constructor->isCopyOrMoveConstructor())
2848 if (FunctionTemplate) {
2856 }
else if (isFriend) {
2862 Record->makeDeclVisibleInContext(Method);
2873 if (Method->
hasAttr<UsedAttr>()) {
2874 if (
const auto *A = dyn_cast<CXXRecordDecl>(Owner)) {
2877 A->getMemberSpecializationInfo())
2878 Loc = MSInfo->getPointOfInstantiation();
2879 else if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(A))
2880 Loc = Spec->getPointOfInstantiation();
2906Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
2908 assert(
D->getTypeForDecl()->isTemplateTypeParmType());
2910 std::optional<unsigned> NumExpanded;
2913 if (
D->isPackExpansion() && !
D->isExpandedParameterPack()) {
2914 assert(TC->getTemplateArgsAsWritten() &&
2915 "type parameter can only be an expansion when explicit arguments "
2921 for (
auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
2927 bool RetainExpansion =
false;
2929 cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
2932 TC->hasExplicitTemplateArgs() ?
2933 TC->getTemplateArgsAsWritten()->getRAngleLoc() :
2934 TC->getConceptNameInfo().getEndLoc()),
2935 Unexpanded, TemplateArgs, Expand, RetainExpansion, NumExpanded))
2944 D->hasTypeConstraint(), NumExpanded);
2948 if (
auto *TC =
D->getTypeConstraint()) {
2954 EvaluateConstraints))
2958 if (
D->hasDefaultArgument() && !
D->defaultArgumentWasInherited()) {
2972Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
2975 TypeLoc TL =
D->getTypeSourceInfo()->getTypeLoc();
2978 bool IsExpandedParameterPack =
false;
2983 if (
D->isExpandedParameterPack()) {
2986 ExpandedParameterPackTypes.reserve(
D->getNumExpansionTypes());
2987 ExpandedParameterPackTypesAsWritten.reserve(
D->getNumExpansionTypes());
2988 for (
unsigned I = 0, N =
D->getNumExpansionTypes(); I != N; ++I) {
2990 SemaRef.
SubstType(
D->getExpansionTypeSourceInfo(I), TemplateArgs,
3000 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
3001 ExpandedParameterPackTypes.push_back(NewT);
3004 IsExpandedParameterPack =
true;
3005 DI =
D->getTypeSourceInfo();
3007 }
else if (
D->isPackExpansion()) {
3019 bool RetainExpansion =
false;
3020 std::optional<unsigned> OrigNumExpansions =
3022 std::optional<unsigned> NumExpansions = OrigNumExpansions;
3024 Pattern.getSourceRange(),
3027 Expand, RetainExpansion,
3032 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3045 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
3046 ExpandedParameterPackTypes.push_back(NewT);
3052 IsExpandedParameterPack =
true;
3053 DI =
D->getTypeSourceInfo();
3075 DI = SemaRef.
SubstType(
D->getTypeSourceInfo(), TemplateArgs,
3089 if (IsExpandedParameterPack)
3093 D->getPosition(),
D->getIdentifier(),
T, DI, ExpandedParameterPackTypes,
3094 ExpandedParameterPackTypesAsWritten);
3102 if (AutoLoc.isConstrained()) {
3104 if (IsExpandedParameterPack)
3107 else if (
auto *Constraint = dyn_cast_if_present<CXXFoldExpr>(
3108 D->getPlaceholderTypeConstraint()))
3109 EllipsisLoc = Constraint->getEllipsisLoc();
3123 if (
D->hasDefaultArgument() && !
D->defaultArgumentWasInherited()) {
3142 for (
const auto &
P : *Params) {
3143 if (
P->isTemplateParameterPack())
3155TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
3162 bool IsExpandedParameterPack =
false;
3164 if (
D->isExpandedParameterPack()) {
3168 ExpandedParams.reserve(
D->getNumExpansionTemplateParameters());
3169 for (
unsigned I = 0, N =
D->getNumExpansionTemplateParameters();
3176 ExpandedParams.push_back(Expansion);
3179 IsExpandedParameterPack =
true;
3180 InstParams = TempParams;
3181 }
else if (
D->isPackExpansion()) {
3192 bool RetainExpansion =
false;
3193 std::optional<unsigned> NumExpansions;
3198 Expand, RetainExpansion,
3203 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3209 ExpandedParams.push_back(Expansion);
3215 IsExpandedParameterPack =
true;
3216 InstParams = TempParams;
3238 if (IsExpandedParameterPack)
3242 D->getPosition(),
D->getIdentifier(),
D->wasDeclaredWithTypename(),
3243 InstParams, ExpandedParams);
3249 D->wasDeclaredWithTypename(), InstParams);
3250 if (
D->hasDefaultArgument() && !
D->defaultArgumentWasInherited()) {
3252 D->getDefaultArgument().getTemplateQualifierLoc();
3256 QualifierLoc,
D->getDefaultArgument().getArgument().getAsTemplate(),
3257 D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
3262 D->getDefaultArgument().getTemplateQualifierLoc(),
3263 D->getDefaultArgument().getTemplateNameLoc()));
3281 D->getNamespaceKeyLocation(),
3282 D->getQualifierLoc(),
3283 D->getIdentLocation(),
3284 D->getNominatedNamespace(),
3285 D->getCommonAncestor());
3301 for (
auto *Shadow :
D->shadows()) {
3305 NamedDecl *OldTarget = Shadow->getTargetDecl();
3306 if (
auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
3307 if (
auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
3308 OldTarget = BaseShadow;
3312 dyn_cast<UnresolvedUsingIfExistsDecl>(Shadow->getTargetDecl())) {
3314 SemaRef.
Context, Owner, EmptyD->getLocation(), EmptyD->getDeclName());
3317 Shadow->getLocation(), OldTarget, TemplateArgs));
3329 Shadow->getLocation(), OldPrev, TemplateArgs));
3332 nullptr, Inst, InstTarget, PrevDecl);
3335 if (isFunctionScope)
3363 if (
auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.
CurContext))
3369 bool CheckRedeclaration = Owner->
isRecord();
3371 RedeclarationKind::ForVisibleRedeclaration);
3380 SS.
Adopt(QualifierLoc);
3381 if (CheckRedeclaration) {
3382 Prev.setHideTags(
false);
3387 D->hasTypename(), SS,
3451Decl *TemplateDeclInstantiator::VisitConstructorUsingShadowDecl(
3457template <
typename T>
3458Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
3459 T *
D,
bool InstantiatingPackElement) {
3461 if (
D->isPackExpansion() && !InstantiatingPackElement) {
3469 bool RetainExpansion =
false;
3470 std::optional<unsigned> NumExpansions;
3473 Expand, RetainExpansion, NumExpansions))
3478 assert(!RetainExpansion &&
3479 "should never need to retain an expansion for UsingPackDecl");
3485 return instantiateUnresolvedUsingDecl(
D,
true);
3496 SemaRef.
Diag(
D->getEllipsisLoc(),
3497 diag::err_using_decl_redeclaration_expansion);
3503 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3505 Decl *Slice = instantiateUnresolvedUsingDecl(
D,
true);
3512 Expansions.push_back(cast<NamedDecl>(Slice));
3531 SS.
Adopt(QualifierLoc);
3538 bool InstantiatingSlice =
D->getEllipsisLoc().isValid() &&
3543 bool IsUsingIfExists =
D->template hasAttr<UsingIfExistsAttr>();
3546 TD, TypenameLoc, SS, NameInfo, EllipsisLoc,
3548 true, IsUsingIfExists);
3557Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
3559 return instantiateUnresolvedUsingDecl(
D);
3562Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
3564 return instantiateUnresolvedUsingDecl(
D);
3567Decl *TemplateDeclInstantiator::VisitUnresolvedUsingIfExistsDecl(
3569 llvm_unreachable(
"referring to unresolved decl out of UsingShadowDecl");
3574 for (
auto *UD :
D->expansions()) {
3577 Expansions.push_back(NewUD);
3588Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
3591 for (
auto *I :
D->varlists()) {
3593 assert(isa<DeclRefExpr>(Var) &&
"threadprivate arg is not a DeclRefExpr");
3594 Vars.push_back(Var);
3608 for (
auto *I :
D->varlists()) {
3610 assert(isa<DeclRefExpr>(Var) &&
"allocate arg is not a DeclRefExpr");
3611 Vars.push_back(Var);
3617 if (
auto *AC = dyn_cast<OMPAllocatorClause>(
C)) {
3622 NewE.
get(), AC->getBeginLoc(), AC->getLParenLoc(), AC->getEndLoc());
3623 }
else if (
auto *AC = dyn_cast<OMPAlignClause>(
C)) {
3628 NewE.
get(), AC->getBeginLoc(), AC->getLParenLoc(), AC->getEndLoc());
3633 Clauses.push_back(IC);
3638 if (Res.
get().isNull())
3640 return Res.
get().getSingleDecl();
3645 "Requires directive cannot be instantiated within a dependent context");
3648Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
3651 const bool RequiresInstantiation =
3652 D->getType()->isDependentType() ||
3653 D->getType()->isInstantiationDependentType() ||
3654 D->getType()->containsUnexpandedParameterPack();
3656 if (RequiresInstantiation) {
3662 SubstReductionType =
D->getType();
3664 if (SubstReductionType.
isNull())
3666 Expr *Combiner =
D->getCombiner();
3668 bool IsCorrect =
true;
3670 std::pair<QualType, SourceLocation> ReductionTypes[] = {
3672 auto *PrevDeclInScope =
D->getPrevDeclInScope();
3673 if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
3674 PrevDeclInScope = cast<OMPDeclareReductionDecl>(
3679 nullptr, Owner,
D->getDeclName(), ReductionTypes,
D->
getAccess(),
3681 auto *NewDRD = cast<OMPDeclareReductionDecl>(DRD.get().getSingleDecl());
3683 Expr *SubstCombiner =
nullptr;
3684 Expr *SubstInitializer =
nullptr;
3690 cast<DeclRefExpr>(
D->getCombinerIn())->getDecl(),
3691 cast<DeclRefExpr>(NewDRD->getCombinerIn())->getDecl());
3693 cast<DeclRefExpr>(
D->getCombinerOut())->getDecl(),
3694 cast<DeclRefExpr>(NewDRD->getCombinerOut())->getDecl());
3695 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
3698 SubstCombiner = SemaRef.
SubstExpr(Combiner, TemplateArgs).
get();
3708 cast<DeclRefExpr>(
D->getInitOrig())->getDecl(),
3709 cast<DeclRefExpr>(NewDRD->getInitOrig())->getDecl());
3711 cast<DeclRefExpr>(
D->getInitPriv())->getDecl(),
3712 cast<DeclRefExpr>(NewDRD->getInitPriv())->getDecl());
3717 cast<VarDecl>(cast<DeclRefExpr>(
D->getInitPriv())->getDecl());
3718 IsCorrect = IsCorrect && OldPrivParm->hasInit();
3724 NewDRD, SubstInitializer, OmpPrivParm);
3726 IsCorrect = IsCorrect && SubstCombiner &&
3729 SubstInitializer) ||
3731 !SubstInitializer));
3742 const bool RequiresInstantiation =
3743 D->getType()->isDependentType() ||
3744 D->getType()->isInstantiationDependentType() ||
3745 D->getType()->containsUnexpandedParameterPack();
3748 if (RequiresInstantiation) {
3754 SubstMapperTy =
D->getType();
3756 if (SubstMapperTy.
isNull())
3759 auto *PrevDeclInScope =
D->getPrevDeclInScope();
3760 if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
3761 PrevDeclInScope = cast<OMPDeclareMapperDecl>(
3765 bool IsCorrect =
true;
3771 (*
D->clauselist_begin())->getBeginLoc());
3776 cast<DeclRefExpr>(
D->getMapperVarRef())->getDecl(),
3777 cast<DeclRefExpr>(MapperVarRef.
get())->getDecl());
3778 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
3783 auto *OldC = cast<OMPMapClause>(
C);
3785 for (
Expr *OE : OldC->varlists()) {
3791 NewVars.push_back(NE);
3799 SS.
Adopt(NewQualifierLoc);
3805 OldC->getIteratorModifier(), OldC->getMapTypeModifiers(),
3806 OldC->getMapTypeModifiersLoc(), SS, NewNameInfo, OldC->getMapType(),
3807 OldC->isImplicitMapType(), OldC->getMapLoc(), OldC->getColonLoc(),
3809 Clauses.push_back(NewC);
3815 nullptr, Owner,
D->getDeclName(), SubstMapperTy,
D->
getLocation(),
3816 VN,
D->
getAccess(), MapperVarRef.
get(), Clauses, PrevDeclInScope);
3817 Decl *NewDMD = DG.
get().getSingleDecl();
3822Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
3824 llvm_unreachable(
"Should not be met in templates");
3834 if (Inst && !
D->getDescribedFunctionTemplate())
3844 llvm_unreachable(
"There are only CXXRecordDecls in C++");
3848TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
3855 "can only instantiate an explicit specialization "
3856 "for a member class template");
3863 if (!InstClassTemplate)
3870 D->getTemplateArgsAsWritten()) {
3871 InstTemplateArgs.
setLAngleLoc(TemplateArgsInfo->getLAngleLoc());
3872 InstTemplateArgs.
setRAngleLoc(TemplateArgsInfo->getRAngleLoc());
3875 TemplateArgs, InstTemplateArgs))
3883 InstTemplateArgs,
false,
3884 SugaredConverted, CanonicalConverted,
3890 void *InsertPos =
nullptr;
3899 D->getSpecializationKind(),
3919 D->isThisDeclarationADefinition()) {
3922 diag::note_previous_definition);
3930 D->
getLocation(), InstClassTemplate, CanonicalConverted, PrevDecl);
3954 if (
D->isThisDeclarationADefinition() &&
3968 assert(VarTemplate &&
3969 "A template specialization without specialized template?");
3974 if (!InstVarTemplate)
3979 D->getTemplateArgsAsWritten()) {
3980 VarTemplateArgsInfo.
setLAngleLoc(TemplateArgsInfo->getLAngleLoc());
3981 VarTemplateArgsInfo.
setRAngleLoc(TemplateArgsInfo->getRAngleLoc());
3984 TemplateArgs, VarTemplateArgsInfo))
3991 VarTemplateArgsInfo,
false,
3992 SugaredConverted, CanonicalConverted,
3997 void *InsertPos =
nullptr;
4011 InstVarTemplate,
D, VarTemplateArgsInfo, CanonicalConverted, PrevDecl);
4022 SemaRef.
SubstType(
D->getTypeSourceInfo(), TemplateArgs,
4023 D->getTypeSpecStartLoc(),
D->getDeclName());
4028 SemaRef.
Diag(
D->
getLocation(), diag::err_variable_instantiates_to_function)
4029 <<
D->isStaticDataMember() << DI->
getType();
4036 VarTemplate, DI->
getType(), DI,
D->getStorageClass(), Converted);
4039 void *InsertPos =
nullptr;
4052 StartingScope,
false, PrevDecl);
4058 llvm_unreachable(
"@defs is not supported in Objective-C++");
4065 "cannot instantiate %0 yet");
4073 llvm_unreachable(
"Concept definitions cannot reside inside a template");
4076Decl *TemplateDeclInstantiator::VisitImplicitConceptSpecializationDecl(
4078 llvm_unreachable(
"Concept specializations cannot reside inside a template");
4088 llvm_unreachable(
"Unexpected decl");
4099 SubstD = Instantiator.Visit(D);
4114 SemaRef.
Context.
BoolTy, FPT->getParamTypes(), FPT->getExtProtoInfo());
4125 assert(OldLoc &&
"type of function is not a function type?");
4127 for (
unsigned I = 0, N = OldLoc.getNumParams(); I != N; ++I)
4128 NewLoc.
setParam(I, OldLoc.getParam(I));
4138 if (Spaceship->isInvalidDecl())
4150 if (
auto *MD = dyn_cast<CXXMethodDecl>(Spaceship)) {
4155 assert(Spaceship->getFriendObjectKind() &&
4156 "defaulted spaceship is neither a member nor a friend");
4166 cast<NamedDecl>(R), Spaceship->getBeginLoc());
4170 return cast_or_null<FunctionDecl>(R);
4184 unsigned N = L->
size();
4188 for (
auto &
P : *L) {
4190 Params.push_back(
D);
4210 bool EvaluateConstraints) {
4257 ClassTemplate, PartialSpec->
getLocation(), InstTemplateArgs,
4258 false, SugaredConverted, CanonicalConverted))
4264 CanonicalConverted))
4269 void *InsertPos =
nullptr;
4284 ClassTemplate, CanonicalConverted, CanonType,
4312 diag::err_partial_spec_redeclared)
4314 SemaRef.
Diag(PrevDecl->
getLocation(), diag::note_prev_partial_spec_here)
4326 return InstPartialSpec;
4370 VarTemplate, PartialSpec->
getLocation(), InstTemplateArgs,
4371 false, SugaredConverted, CanonicalConverted))
4377 CanonicalConverted))
4382 void *InsertPos =
nullptr;
4396 diag::err_variable_instantiates_to_function)
4433 diag::err_var_partial_spec_redeclared)
4436 diag::note_var_prev_partial_spec_here);
4447 LateAttrs, Owner, StartingScope);
4449 return InstPartialSpec;
4456 assert(OldTInfo &&
"substituting function without type source info");
4457 assert(Params.empty() &&
"parameter vector is non-empty at start");
4462 ThisContext = cast<CXXRecordDecl>(Owner);
4463 ThisTypeQuals = Method->getFunctionObjectParameterType().getQualifiers();
4467 OldTInfo, TemplateArgs,
D->getTypeSpecStartLoc(),
D->getDeclName(),
4468 ThisContext, ThisTypeQuals, EvaluateConstraints);
4474 if (NewTInfo != OldTInfo) {
4478 unsigned NewIdx = 0;
4479 for (
unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
4480 OldIdx != NumOldParams; ++OldIdx) {
4481 ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
4487 std::optional<unsigned> NumArgumentsInExpansion;
4489 NumArgumentsInExpansion =
4492 if (!NumArgumentsInExpansion) {
4496 Params.push_back(NewParam);
4497 Scope->InstantiatedLocal(OldParam, NewParam);
4500 Scope->MakeInstantiatedLocalArgPack(OldParam);
4501 for (
unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
4503 Params.push_back(NewParam);
4504 Scope->InstantiatedLocalPackArg(OldParam, NewParam);
4513 cast<FunctionProtoType>(OldProtoLoc.getType());
4514 for (
unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
4524 cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
4527 Params.push_back(Parm);
4544 TemplateArgs, ParamTypes, &Params,
4557 for (
auto *
decl : PatternDecl->
decls()) {
4558 if (!isa<VarDecl>(
decl) || isa<ParmVarDecl>(
decl))
4564 auto it = llvm::find_if(
Function->decls(), [&](
Decl *inst) {
4565 VarDecl *InstVD = dyn_cast<VarDecl>(inst);
4566 return InstVD && InstVD->isLocalVarDecl() &&
4567 InstVD->getIdentifier() == II;
4573 Scope.InstantiatedLocal(VD, *it);
4574 LSI->
addCapture(cast<VarDecl>(*it),
false,
false,
4580bool Sema::addInstantiatedParametersToScope(
4584 unsigned FParamIdx = 0;
4585 for (
unsigned I = 0, N = PatternDecl->
getNumParams(); I != N; ++I) {
4589 assert(FParamIdx < Function->getNumParams());
4607 Scope.InstantiatedLocal(PatternParam, FunctionParam);
4613 Scope.MakeInstantiatedLocalArgPack(PatternParam);
4614 std::optional<unsigned> NumArgumentsInExpansion =
4616 if (NumArgumentsInExpansion) {
4619 for (
unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
4632 Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
4664 false, std::nullopt,
4671 L->DefaultArgumentInstantiated(Param);
4693 Diag(PointOfInstantiation, diag::err_exception_spec_cycle) <<
Decl;
4705 false, std::nullopt,
4713 if (addInstantiatedParametersToScope(
Decl, Template,
Scope, TemplateArgs)) {
4753 if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
4754 ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
4755 if (isa<FunctionTemplateDecl>(ActiveInst.Entity)) {
4757 {ActiveInst.Entity->getCanonicalDecl(), ActiveInst.Kind});
4759 ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
4760 ActiveInst.Entity = New;
4766 assert(Proto &&
"Function template without prototype?");
4790 assert(NewProto &&
"Template instantiation without function prototype?");
4808 LateAttrs, StartingScope);
4824 if (isa<CXXDestructorDecl>(New) && SemaRef.
getLangOpts().CPlusPlus11)
4840 Lookups.reserve(DFI->getUnqualifiedLookups().size());
4841 bool AnyChanged =
false;
4844 DA.getDecl(), TemplateArgs);
4847 AnyChanged |= (
D != DA.getDecl());
4883 bool DefinitionRequired,
4891 Function->getTemplateSpecializationKindForInstantiation();
4898 !DefinitionRequired)
4903 if (
Function->isDefined(ExistingDefn,
4917 assert(PatternDecl &&
"instantiating a non-template");
4920 Stmt *Pattern =
nullptr;
4922 Pattern = PatternDef->
getBody(PatternDef);
4923 PatternDecl = PatternDef;
4925 PatternDef =
nullptr;
4931 Function->getInstantiatedFromMemberFunction(),
4932 PatternDecl, PatternDef, TSK,
4933 DefinitionRequired)) {
4934 if (DefinitionRequired)
4937 (
Function->isConstexpr() && !Recursive)) {
4941 Function->setInstantiationIsPending(
true);
4943 std::make_pair(
Function, PointOfInstantiation));
4947 Diag(PointOfInstantiation, diag::warn_func_template_missing)
4951 Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
4962 Function->setInstantiationIsPending(
true);
4964 std::make_pair(
Function, PointOfInstantiation));
4968 llvm::TimeTraceScope TimeScope(
"InstantiateFunction", [&]() {
4969 llvm::TimeTraceMetadata M;
4970 llvm::raw_string_ostream
OS(M.Detail);
4973 if (llvm::isTimeTraceVerbose()) {
5000 "missing LateParsedTemplate");
5002 Pattern = PatternDecl->
getBody(PatternDecl);
5009 "unexpected kind of function template definition");
5024 for (
auto *
D =
Function->getMostRecentDecl(); ;
5026 D->setImplicitlyInline();
5036 "instantiating function definition");
5040 Function->setVisibleDespiteOwningModule();
5055 ThisTypeQuals = Method->getMethodQualifiers();
5065 bool MergeWithParentScope =
false;
5067 MergeWithParentScope =
5068 Rec->isLocalClass() && !
Function->isFunctionTemplateSpecialization();
5071 auto RebuildTypeSourceInfoForDefaultSpecialMembers = [&]() {
5077 "Special member needs to be defaulted");
5085 auto *NewRec = dyn_cast<CXXRecordDecl>(
Function->getDeclContext());
5086 const auto *PatternRec =
5088 if (!NewRec || !PatternRec)
5090 if (!PatternRec->isLambda())
5093 struct SpecialMemberTypeInfoRebuilder
5113 getDerived().TransformDecl(TL.
getNameLoc(),
T->getDecl()));
5115 return Base::TransformRecordType(TLB, TL);
5117 QualType Result = getDerived().RebuildRecordType(NewDecl);
5118 if (Result.isNull())
5125 } IR{*
this, PatternRec, NewRec};
5128 assert(NewSI &&
"Type Transform failed?");
5130 Function->setTypeSourceInfo(NewSI);
5134 assert(NewParmSI &&
"Type transformation failed.");
5140 RebuildTypeSourceInfoForDefaultSpecialMembers();
5145 std::nullopt,
false, PatternDecl);
5163 if (addInstantiatedParametersToScope(
Function, PatternDecl,
Scope,
5180 Ctor->isDefaultConstructor()) {
5186 Body =
SubstStmt(Pattern, TemplateArgs);
5198 Listener->FunctionDefinitionInstantiated(
Function);
5208 LocalInstantiations.
perform();
5210 GlobalInstantiations.perform();
5236 bool IsMemberSpec =
false;
5238 if (
auto *PartialSpec =
5239 dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar)) {
5240 assert(PartialSpecArgs);
5241 IsMemberSpec = PartialSpec->isMemberSpecialization();
5243 PartialSpec, PartialSpecArgs->
asArray(),
false);
5246 IsMemberSpec =
VarTemplate->isMemberSpecialization();
5258 return cast_or_null<VarTemplateSpecializationDecl>(
5260 VarTemplate, FromVar, TemplateArgsInfo, Converted));
5267 "don't have a definition to instantiate from");
5296 bool InstantiatingVarTemplate,
5300 bool InstantiatingVarTemplatePartialSpec =
5301 isa<VarTemplatePartialSpecializationDecl>(OldVar) &&
5302 isa<VarTemplatePartialSpecializationDecl>(NewVar);
5305 bool InstantiatingSpecFromTemplate =
5306 isa<VarTemplateSpecializationDecl>(NewVar) &&
5308 isa<VarTemplatePartialSpecializationDecl>(OldVar));
5331 if (OldVar->
isUsed(
false))
5353 }
else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
5356 }
else if (PrevDeclForVarTemplateSpecialization) {
5357 Previous.addDecl(PrevDeclForVarTemplateSpecialization);
5361 if (!InstantiatingVarTemplate) {
5379 !InstantiatingSpecFromTemplate)
5386 dyn_cast<VarTemplateSpecializationDecl>(OldVar)) {
5388 !isa<VarTemplatePartialSpecializationDecl>(OldVTSD))
5389 cast<VarTemplateSpecializationDecl>(NewVar)->setSpecializationKind(
5398 if (InstantiatingVarTemplate || InstantiatingVarTemplatePartialSpec) {
5403 }
else if (InstantiatingSpecFromTemplate ||
5425 L->VariableDefinitionInstantiated(Var);
5449 if (!
Init.isInvalid()) {
5452 if (Var->
hasAttr<DLLImportAttr>() &&
5456 }
else if (InitExpr) {
5492 bool DefinitionRequired,
bool AtEndOfTU) {
5504 assert(PatternDecl &&
"no pattern for templated variable");
5509 dyn_cast<VarTemplateSpecializationDecl>(Var);
5520 (PatternDecl = PatternDecl->
getFirstDecl())->hasInit() &&
5528 "instantiating variable initializer");
5546 PreviousContext.
pop();
5550 LocalInstantiations.
perform();
5552 GlobalInstantiations.
perform();
5556 "not a static data member?");
5565 if (!Def && !DefinitionRequired) {
5568 std::make_pair(Var, PointOfInstantiation));
5573 Diag(PointOfInstantiation, diag::warn_var_template_missing)
5577 Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
5588 PatternDecl, Def, TSK,
5589 DefinitionRequired))
5606 struct PassToConsumerRAII {
5611 : Consumer(Consumer), Var(Var) { }
5613 ~PassToConsumerRAII() {
5616 } PassToConsumerRAII(
Consumer, Var);
5623 PointOfInstantiation);
5631 "instantiating variable definition");
5651 }
else if (!VarSpec) {
5680 cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
5691 PreviousContext.
pop();
5694 PassToConsumerRAII.Var = Var;
5701 LocalInstantiations.
perform();
5703 GlobalInstantiations.
perform();
5715 for (
const auto *
Init : Tmpl->
inits()) {
5718 if (!
Init->isWritten())
5723 if (
Init->isPackExpansion()) {
5725 TypeLoc BaseTL =
Init->getTypeSourceInfo()->getTypeLoc();
5729 bool ShouldExpand =
false;
5730 bool RetainExpansion =
false;
5731 std::optional<unsigned> NumExpansions;
5735 TemplateArgs, ShouldExpand,
5742 assert(ShouldExpand &&
"Partial instantiation of base initializer?");
5745 for (
unsigned I = 0; I != *NumExpansions; ++I) {
5759 Init->getSourceLocation(),
5768 BaseTInfo, TempInit.
get(),
5776 NewInits.push_back(NewInit.
get());
5791 if (
Init->isDelegatingInitializer() ||
Init->isBaseInitializer()) {
5794 Init->getSourceLocation(),
5802 if (
Init->isBaseInitializer())
5808 }
else if (
Init->isMemberInitializer()) {
5810 Init->getMemberLocation(),
5820 Init->getSourceLocation());
5821 }
else if (
Init->isIndirectMemberInitializer()) {
5824 Init->getMemberLocation(),
5825 Init->getIndirectMember(), TemplateArgs));
5827 if (!IndirectMember) {
5834 Init->getSourceLocation());
5841 NewInits.push_back(NewInit.
get());
5860 Instance = Instance->getCanonicalDecl();
5861 if (Pattern == Instance)
return true;
5862 Instance = Instance->getInstantiatedFromMemberTemplate();
5873 Instance = Instance->getCanonicalDecl();
5874 if (Pattern == Instance)
return true;
5875 Instance = Instance->getInstantiatedFromMemberTemplate();
5885 = cast<ClassTemplatePartialSpecializationDecl>(Pattern->
getCanonicalDecl());
5887 Instance = cast<ClassTemplatePartialSpecializationDecl>(
5888 Instance->getCanonicalDecl());
5889 if (Pattern == Instance)
5891 Instance = Instance->getInstantiatedFromMember();
5902 Instance = Instance->getCanonicalDecl();
5903 if (Pattern == Instance)
return true;
5904 Instance = Instance->getInstantiatedFromMemberClass();
5915 Instance = Instance->getCanonicalDecl();
5916 if (Pattern == Instance)
return true;
5917 Instance = Instance->getInstantiatedFromMemberFunction();
5928 Instance = Instance->getCanonicalDecl();
5929 if (Pattern == Instance)
return true;
5930 Instance = Instance->getInstantiatedFromMemberEnum();
5957 bool OtherIsPackExpansion;
5959 if (
auto *OtherUUD = dyn_cast<T>(
Other)) {
5960 OtherIsPackExpansion = OtherUUD->isPackExpansion();
5962 }
else if (
auto *OtherUPD = dyn_cast<UsingPackDecl>(
Other)) {
5963 OtherIsPackExpansion =
true;
5964 OtherFrom = OtherUPD->getInstantiatedFromUsingDecl();
5965 }
else if (
auto *OtherUD = dyn_cast<UsingDecl>(
Other)) {
5966 OtherIsPackExpansion =
false;
5971 return Pattern->isPackExpansion() == OtherIsPackExpansion &&
5977 assert(Instance->isStaticDataMember());
5982 Instance = Instance->getCanonicalDecl();
5983 if (Pattern == Instance)
return true;
5984 Instance = Instance->getInstantiatedFromStaticDataMember();
5993 if (
auto *UUD = dyn_cast<UnresolvedUsingTypenameDecl>(
D))
5996 if (
auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(
D))
6002 if (
auto *
Record = dyn_cast<CXXRecordDecl>(
Other))
6008 if (
auto *
Enum = dyn_cast<EnumDecl>(
Other))
6011 if (
auto *Var = dyn_cast<VarDecl>(
Other))
6015 if (
auto *Temp = dyn_cast<ClassTemplateDecl>(
Other))
6018 if (
auto *Temp = dyn_cast<FunctionTemplateDecl>(
Other))
6021 if (
auto *PartialSpec =
6022 dyn_cast<ClassTemplatePartialSpecializationDecl>(
Other))
6026 if (
auto *Field = dyn_cast<FieldDecl>(
Other)) {
6027 if (!Field->getDeclName()) {
6030 cast<FieldDecl>(
D));
6034 if (
auto *Using = dyn_cast<UsingDecl>(
Other))
6037 if (
auto *Shadow = dyn_cast<UsingShadowDecl>(
Other))
6040 return D->getDeclName() &&
6041 D->getDeclName() == cast<NamedDecl>(
Other)->getDeclName();
6044template<
typename ForwardIterator>
6047 ForwardIterator first,
6048 ForwardIterator last) {
6049 for (; first != last; ++first)
6051 return cast<NamedDecl>(*first);
6058 if (
NamedDecl *
D = dyn_cast<NamedDecl>(DC)) {
6060 return cast_or_null<DeclContext>(ID);
6075 return cast<Decl>(DC)->getTemplateDepth() > Level;
6080 bool FindingInstantiatedContext) {
6102 if (isa<ParmVarDecl>(
D) && !ParentDependsOnArgs &&
6103 !cast<ParmVarDecl>(
D)->getType()->isInstantiationDependentType())
6105 if (isa<ParmVarDecl>(
D) || isa<NonTypeTemplateParmDecl>(
D) ||
6106 isa<TemplateTypeParmDecl>(
D) || isa<TemplateTemplateParmDecl>(
D) ||
6108 isa<OMPDeclareReductionDecl>(ParentDC) ||
6109 isa<OMPDeclareMapperDecl>(ParentDC))) ||
6110 (isa<CXXRecordDecl>(
D) && cast<CXXRecordDecl>(
D)->isLambda() &&
6111 cast<CXXRecordDecl>(
D)->getTemplateDepth() >
6118 return cast<NamedDecl>(FD);
6121 assert(PackIdx != -1 &&
6122 "found declaration pack but not pack expanding");
6124 return cast<NamedDecl>((*
Found->get<DeclArgumentPack *>())[PackIdx]);
6131 if (isa<NonTypeTemplateParmDecl>(
D) || isa<TemplateTypeParmDecl>(
D) ||
6132 isa<TemplateTemplateParmDecl>(
D))
6151 bool NeedInstantiate =
false;
6153 NeedInstantiate = RD->isLocalClass();
6154 else if (isa<TypedefNameDecl>(
D) &&
6156 NeedInstantiate =
true;
6158 NeedInstantiate = isa<EnumDecl>(
D);
6159 if (NeedInstantiate) {
6162 return cast<TypeDecl>(Inst);
6167 assert(isa<LabelDecl>(
D));
6170 assert(Inst &&
"Failed to instantiate label??");
6173 return cast<LabelDecl>(Inst);
6177 if (!
Record->isDependentContext())
6186 dyn_cast<ClassTemplateSpecializationDecl>(
Record))
6187 ClassTemplate = Spec->getSpecializedTemplate()->getCanonicalDecl();
6198 if (
CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
6202 = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
6222 auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FD);
6223 if (Guide && Guide->isImplicit()) {
6231 Unpacked = Arg.pack_elements();
6261 if (FindingInstantiatedContext &&
6263 Loc, cast<ClassTemplateSpecializationDecl>(SubstRecord))) {
6264 Diag(
Loc, diag::err_specialization_not_primary_template)
6281 if (!ParentDependsOnArgs)
6295 bool IsBeingInstantiated =
false;
6296 if (
CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
6297 if (!Spec->isDependentContext()) {
6300 assert(Tag &&
"type of non-dependent record is not a RecordType");
6301 if (Tag->isBeingDefined())
6302 IsBeingInstantiated =
true;
6303 if (!Tag->isBeingDefined() &&
6307 ParentDC = Tag->getDecl();
6314 if (
auto Name =
D->getDeclName()) {
6339 if (isa<UsingShadowDecl>(
D)) {
6346 }
else if (IsBeingInstantiated) {
6352 Diag(
Loc, diag::err_member_not_yet_instantiated)
6360 EnumDecl *
Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
6365 Diag(
Loc, diag::err_enumerator_does_not_exist)
6372 llvm_unreachable(
"Unable to find instantiation of declaration!");
6383 std::deque<PendingImplicitInstantiation> delayedPCHInstantiations;
6398 bool DefinitionRequired =
Function->getTemplateSpecializationKind() ==
6404 DefinitionRequired,
true);
6410 DefinitionRequired,
true);
6412 Function->setInstantiationIsPending(
false);
6415 if (!LocalOnly &&
LangOpts.PCHInstantiateTemplates &&
6417 delayedPCHInstantiations.push_back(Inst);
6422 VarDecl *Var = cast<VarDecl>(Inst.first);
6425 isa<VarTemplateSpecializationDecl>(Var)) &&
6426 "Not a static data member, nor a variable template"
6427 " specialization?");
6439 llvm_unreachable(
"Cannot instantitiate an undeclared specialization.");
6454 "instantiating variable definition");
6461 DefinitionRequired,
true);
6464 if (!LocalOnly &&
LangOpts.PCHInstantiateTemplates)
6470 for (
auto *DD : Pattern->
ddiags()) {
6471 switch (DD->getKind()) {
Defines the clang::ASTContext interface.
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
llvm::MachO::Record Record
This file declares semantic analysis functions specific to AMDGPU.
This file declares semantic analysis for CUDA constructs.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
This file declares semantic analysis functions specific to Swift.
static void instantiateDependentAMDGPUWavesPerEUAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AMDGPUWavesPerEUAttr &Attr, Decl *New)
static NamedDecl * findInstantiationOf(ASTContext &Ctx, NamedDecl *D, ForwardIterator first, ForwardIterator last)
static void instantiateDependentAMDGPUMaxNumWorkGroupsAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AMDGPUMaxNumWorkGroupsAttr &Attr, Decl *New)
static void instantiateDependentAMDGPUFlatWorkGroupSizeAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AMDGPUFlatWorkGroupSizeAttr &Attr, Decl *New)
static void instantiateDependentDiagnoseIfAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New)
static QualType adjustFunctionTypeForInstantiation(ASTContext &Context, FunctionDecl *D, TypeSourceInfo *TInfo)
Adjust the given function type for an instantiation of the given declaration, to cope with modificati...
static bool isRelevantAttr(Sema &S, const Decl *D, const Attr *A)
Determine whether the attribute A might be relevant to the declaration D.
static bool isDependentContextAtLevel(DeclContext *DC, unsigned Level)
Determine whether the given context is dependent on template parameters at level Level or below.
static void instantiateDependentModeAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const ModeAttr &Attr, Decl *New)
static void instantiateDependentCUDALaunchBoundsAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const CUDALaunchBoundsAttr &Attr, Decl *New)
static bool isDeclWithinFunction(const Decl *D)
static void instantiateDependentAssumeAlignedAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AssumeAlignedAttr *Aligned, Decl *New)
static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl, const MultiLevelTemplateArgumentList &TemplateArgs)
static void collectUnexpandedParameterPacks(Sema &S, TemplateParameterList *Params, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
static DeclT * getPreviousDeclForInstantiation(DeclT *D)
Get the previous declaration of a declaration for the purposes of template instantiation.
static Expr * instantiateDependentFunctionAttrCondition(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New)
static bool isInstantiationOf(ClassTemplateDecl *Pattern, ClassTemplateDecl *Instance)
static void instantiateDependentHLSLParamModifierAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const HLSLParamModifierAttr *Attr, Decl *New)
static void instantiateDependentAllocAlignAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AllocAlignAttr *Align, Decl *New)
static bool isInstantiationOfStaticDataMember(VarDecl *Pattern, VarDecl *Instance)
static void instantiateOMPDeclareSimdDeclAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const OMPDeclareSimdDeclAttr &Attr, Decl *New)
Instantiation of 'declare simd' attribute and its arguments.
static void instantiateDependentSYCLKernelAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const SYCLKernelAttr &Attr, Decl *New)
static void instantiateDependentAlignValueAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AlignValueAttr *Aligned, Decl *New)
static void instantiateDependentAlignedAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion)
static void instantiateOMPDeclareVariantAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const OMPDeclareVariantAttr &Attr, Decl *New)
Instantiation of 'declare variant' attribute and its arguments.
static void instantiateDependentEnableIfAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New)
static void instantiateDependentAnnotationAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AnnotateAttr *Attr, Decl *New)
static Sema::RetainOwnershipKind attrToRetainOwnershipKind(const Attr *A)
static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other, ASTContext &Ctx)
static bool isInvalid(LocType Loc, bool *Invalid)
Defines the SourceManager interface.
Defines the clang::TypeLoc interface and its subclasses.
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs.
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
virtual void HandleCXXStaticMemberVarInstantiation(VarDecl *D)
HandleCXXStaticMemberVarInstantiation - Tell the consumer that this.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
unsigned getManglingNumber(const NamedDecl *ND, bool ForAuxTarget=false) const
TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern)
Remember that the using decl Inst is an instantiation of the using decl Pattern of a class template.
QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool AllowCXX=false, bool IsConditionalOperator=false)
NamedDecl * getInstantiatedFromUsingDecl(NamedDecl *Inst)
If the given using decl Inst is an instantiation of another (possibly unresolved) using decl,...
DeclarationNameTable DeclarationNames
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
QualType getRecordType(const RecordDecl *Decl) const
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
unsigned getStaticLocalNumber(const VarDecl *VD) const
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
void forEachMultiversionedFunctionVersion(const FunctionDecl *FD, llvm::function_ref< void(FunctionDecl *)> Pred) const
Visits all versions of a multiversioned function with the passed predicate.
void setInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst, UsingEnumDecl *Pattern)
Remember that the using enum decl Inst is an instantiation of the using enum decl Pattern of a class ...
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
FieldDecl * getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field)
OMPTraitInfo & getNewOMPTraitInfo()
Return a new OMPTraitInfo object owned by this context.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
void setManglingNumber(const NamedDecl *ND, unsigned Number)
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)
CanQualType UnsignedLongLongTy
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
const TargetInfo & getTargetInfo() const
void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl)
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Represents an access specifier followed by colon ':'.
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Attr - This represents one attribute.
attr::Kind getKind() const
Attr * clone(ASTContext &C) const
SourceLocation getLocation() const
SourceRange getRange() const
SourceLocation getLoc() const
Represents a C++ declaration that introduces decls from somewhere else.
A binding in a decomposition declaration.
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
Represents a C++ constructor within a class.
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
Represents a C++ conversion function within a class.
static CXXConversionDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Represents a C++ deduction guide declaration.
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation, CXXConstructorDecl *Ctor=nullptr, DeductionCandidate Kind=DeductionCandidate::Normal)
Represents a C++ destructor within a class.
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Represents a C++ struct/union/class.
CXXRecordDecl * getDefinition() const
static CXXRecordDecl * CreateLambda(const ASTContext &C, DeclContext *DC, TypeSourceInfo *Info, SourceLocation Loc, unsigned DependencyKind, bool IsGeneric, LambdaCaptureDefault CaptureDefault)
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
void setInstantiationOfMemberClass(CXXRecordDecl *RD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member class RD.
void setDescribedClassTemplate(ClassTemplateDecl *Template)
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Represents a C++ nested-name-specifier or a global scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Declaration of a class template.
void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D, void *InsertPos)
Insert the specified partial specialization knowing that it is not already in.
ClassTemplateDecl * getMostRecentDecl()
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, TemplateParameterList *TPL, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a class template node.
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
ClassTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *D)
Find a class template partial specialization which was instantiated from the given member partial spe...
void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
void setCommonPtr(Common *C)
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template.
Common * getCommonPtr() const
ClassTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
void setInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *PartialSpec)
static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl)
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a class template specialization, which refers to a class template with a given set of temp...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Retrieve the template argument list as written in the sources, if any.
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
void setExternKeywordLoc(SourceLocation Loc)
Sets the location of the extern keyword.
void setSpecializationKind(TemplateSpecializationKind TSK)
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)
Set the template argument list as written in the sources.
Declaration of a C++20 concept.
const TypeClass * getTypePtr() const
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within 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.
bool isFileContext() const
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDecl(Decl *D)
Add the declaration D into this context.
decl_iterator decls_end() const
ddiag_range ddiags() const
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
decl_iterator decls_begin() const
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
SourceLocation getEndLoc() const LLVM_READONLY
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it's a function-local extern declaration.
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
bool isParameterPack() const
Whether this declaration is a parameter pack.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
bool isInIdentifierNamespace(unsigned NS) const
@ FOK_None
Not a friend object.
bool isReferenced() const
Whether any declaration of this entity was referenced.
unsigned getTemplateDepth() const
Determine the number of levels of template parameter surrounding this declaration.
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it's the object of a friend declaration.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
bool isInLocalScopeForInstantiation() const
Determine whether a substitution into this declaration would occur as part of a substitution into a d...
DeclContext * getNonTransparentDeclContext()
Return the non transparent context.
bool isInvalidDecl() const
bool isLocalExternDecl() const
Determine whether this is a block-scope declaration with linkage.
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
const char * getDeclKindName() const
@ IDNS_Ordinary
Ordinary names.
void setImplicit(bool I=true)
void setReferenced(bool R=true)
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
SourceLocation getBeginLoc() const LLVM_READONLY
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
void setLexicalDeclContext(DeclContext *DC)
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
The name of a declaration.
NameKind getNameKind() const
Determine what kind of name this is.
Represents a ValueDecl that came out of a declarator.
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
void setTypeSourceInfo(TypeSourceInfo *TI)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
TypeSourceInfo * getTypeSourceInfo() const
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Represents the type decltype(expr) (C++11).
Expr * getUnderlyingExpr() const
A decomposition declaration.
static DecompositionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation LSquareLoc, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< BindingDecl * > Bindings)
Provides information about a dependent function-template specialization declaration.
Represents a qualified type name for which the type name is dependent.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
RAII object that enters a new expression evaluation context.
An instance of this object exists for each enum constant that is defined.
enumerator_range enumerators() const
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
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,...
EnumDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this enumeration is a member of a specialization of a templated class, determine what kind of temp...
Store information needed for an explicit specifier.
ExplicitSpecKind getKind() const
bool isInvalid() const
Determine if the explicit specifier is invalid.
static ExplicitSpecifier Invalid()
const Expr * getExpr() const
void setKind(ExplicitSpecKind Kind)
static ExplicitSpecifier getFromDecl(FunctionDecl *Function)
This represents one expression.
static bool isPotentialConstantExprUnevaluated(Expr *E, const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExprUnevaluated - Return true if this expression might be usable in a constant exp...
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant,...
Declaration context for names declared as extern "C" in C++.
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, ArrayRef< TemplateParameterList * > FriendTypeTPLists=std::nullopt)
void setUnsupportedFriend(bool Unsupported)
Declaration of a friend template.
static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)
Represents a function declaration or definition.
void setInstantiationIsPending(bool IC)
State that the instantiation of this function is pending.
const ParmVarDecl * getParamDecl(unsigned i) const
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
void setInstantiationOfMemberFunction(FunctionDecl *FD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member function FD.
QualType getReturnType() const
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
bool hasSkippedBody() const
True if the function was a definition but its body was skipped.
FunctionDecl * getDefinition()
Get the definition for this declaration.
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
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...
void setRangeEnd(SourceLocation E)
bool isDefaulted() const
Whether this function is defaulted.
void setIneligibleOrNotSelected(bool II)
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template, TemplateArgumentList *TemplateArgs, void *InsertPos, TemplateSpecializationKind TSK=TSK_ImplicitInstantiation, TemplateArgumentListInfo *TemplateArgsAsWritten=nullptr, SourceLocation PointOfInstantiation=SourceLocation())
Specify that this function declaration is actually a function template specialization.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
DeclarationNameInfo getNameInfo() const
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
DefaultedOrDeletedFunctionInfo * getDefalutedOrDeletedInfo() const
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
Represents a prototype with parameter type info, e.g.
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
QualType getParamType(unsigned i) const
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
ExtProtoInfo getExtProtoInfo() const
FunctionDecl * getExceptionSpecTemplate() const
If this function type has an uninstantiated exception specification, this is the function whose excep...
ArrayRef< QualType > getParamTypes() const
Declaration of a template function.
FunctionTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
ParmVarDecl * getParam(unsigned i) const
void setParam(unsigned i, ParmVarDecl *VD)
ExtInfo getExtInfo() const
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
QualType getReturnType() const
HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
Represents a field injected from an anonymous union/struct into the parent scope.
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, const IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl * > CH)
Description of a constructor that was inherited from a base class.
const TypeClass * getTypePtr() const
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Represents the declaration of a label.
static LabelDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II)
A stack-allocated class that identifies which local variable declaration instantiations are present i...
void InstantiatedLocal(const Decl *D, Decl *Inst)
LocalInstantiationScope * cloneScopes(LocalInstantiationScope *Outermost)
Clone this scope, and all outer scopes, down to the given outermost scope.
llvm::PointerUnion< Decl *, DeclArgumentPack * > * findInstantiationOf(const Decl *D)
Find the instantiation of the declaration D within the current instantiation scope.
Represents the results of name lookup.
An instance of this class represents the declaration of a property member.
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Provides information a specialization of a member of a class template, which may be a member function...
Data structure that captures multiple levels of template argument lists for use in template instantia...
const ArgList & getInnermost() const
Retrieve the innermost template argument list.
void addOuterTemplateArguments(Decl *AssociatedDecl, ArgList Args, bool Final)
Add a new outmost level to the multi-level template argument list.
unsigned getNumLevels() const
Determine the number of levels in this template argument list.
void setKind(TemplateSubstitutionKind K)
unsigned getNumSubstitutedLevels() const
Determine the number of substituted levels in this template argument list.
void addOuterRetainedLevels(unsigned Num)
unsigned getNumRetainedOuterLevels() const
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
bool hasLinkage() const
Determine whether this declaration has linkage.
void setDeclName(DeclarationName N)
Set the name of this declaration.
Represents a C++ namespace alias.
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
bool hasQualifier() const
Evaluates true when this nested-name-specifier location is non-empty.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
This represents '#pragma omp allocate ...' directive.
Pseudo declaration for capturing expressions.
This is a basic class for representing single OpenMP clause.
This represents '#pragma omp declare mapper ...' directive.
This represents '#pragma omp declare reduction ...' directive.
This represents '#pragma omp requires...' directive.
This represents '#pragma omp threadprivate ...' directive.
Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...
bool anyScoreOrCondition(llvm::function_ref< bool(Expr *&, bool)> Cond)
Represents a field declaration created by an @defs(...).
Wrapper for void* pointer.
static OpaquePtr make(QualType P)
SourceLocation getEllipsisLoc() const
TypeLoc getPatternLoc() const
Represents a pack expansion of types.
std::optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
Represents a parameter to a function.
bool hasUninstantiatedDefaultArg() const
Represents a #pragma detect_mismatch line.
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
The collection of all-type qualifiers we support.
Represents a struct/union/class.
Wrapper for source info for record types.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD)
decl_type * 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.
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Represents the body of a requires-expression.
static RequiresExprBodyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc)
Scope - A scope is a transient data structure that is used while parsing the program.
void addAMDGPUFlatWorkGroupSizeAttr(Decl *D, const AttributeCommonInfo &CI, Expr *Min, Expr *Max)
addAMDGPUFlatWorkGroupSizeAttr - Adds an amdgpu_flat_work_group_size attribute to a particular declar...
void addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI, Expr *Min, Expr *Max)
addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu attribute to a particular declaration.
void addAMDGPUMaxNumWorkGroupsAttr(Decl *D, const AttributeCommonInfo &CI, Expr *XExpr, Expr *YExpr, Expr *ZExpr)
addAMDGPUMaxNumWorkGroupsAttr - Adds an amdgpu_max_num_work_groups attribute to a particular declarat...
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
void checkAllowedInitializer(VarDecl *VD)
bool inferObjCARCLifetime(ValueDecl *decl)
void AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI, Sema::RetainOwnershipKind K, bool IsTemplateInstantiation)
DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid)
Called at the end of '#pragma omp declare reduction'.
void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner)
Finish current declare reduction construct initializer.
ExprResult ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S, QualType MapperType, SourceLocation StartLoc, DeclarationName VN)
Build the mapper variable of '#pragma omp declare mapper'.
VarDecl * ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D)
Initialize declare reduction construct initializer.
QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc, TypeResult ParsedType)
Check if the specified type is allowed to be used in 'omp declare reduction' construct.
DeclGroupPtrTy ActOnOpenMPAllocateDirective(SourceLocation Loc, ArrayRef< Expr * > VarList, ArrayRef< OMPClause * > Clauses, DeclContext *Owner=nullptr)
Called on well-formed '#pragma omp allocate'.
DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(Scope *S, DeclContext *DC, DeclarationName Name, ArrayRef< std::pair< QualType, SourceLocation > > ReductionTypes, AccessSpecifier AS, Decl *PrevDeclInScope=nullptr)
Called on start of '#pragma omp declare reduction'.
OMPClause * ActOnOpenMPAllocatorClause(Expr *Allocator, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'allocator' clause.
void EndOpenMPDSABlock(Stmt *CurDirective)
Called on end of data sharing attribute block.
QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc, TypeResult ParsedType)
Check if the specified type is allowed to be used in 'omp declare mapper' construct.
OMPClause * ActOnOpenMPMapClause(Expr *IteratorModifier, ArrayRef< OpenMPMapModifierKind > MapTypeModifiers, ArrayRef< SourceLocation > MapTypeModifiersLoc, CXXScopeSpec &MapperIdScopeSpec, DeclarationNameInfo &MapperId, OpenMPMapClauseKind MapType, bool IsMapTypeImplicit, SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef< Expr * > VarList, const OMPVarListLocTy &Locs, bool NoDiagnose=false, ArrayRef< Expr * > UnresolvedMappers=std::nullopt)
Called on well-formed 'map' clause.
std::optional< std::pair< FunctionDecl *, Expr * > > checkOpenMPDeclareVariantFunction(DeclGroupPtrTy DG, Expr *VariantRef, OMPTraitInfo &TI, unsigned NumAppendArgs, SourceRange SR)
Checks '#pragma omp declare variant' variant function and original functions after parsing of the ass...
void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D)
Initialize declare reduction construct initializer.
void StartOpenMPDSABlock(OpenMPDirectiveKind K, const DeclarationNameInfo &DirName, Scope *CurScope, SourceLocation Loc)
Called on start of new data sharing attribute block.
OMPThreadPrivateDecl * CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef< Expr * > VarList)
Builds a new OpenMPThreadPrivateDecl and checks its correctness.
void ActOnOpenMPDeclareVariantDirective(FunctionDecl *FD, Expr *VariantRef, OMPTraitInfo &TI, ArrayRef< Expr * > AdjustArgsNothing, ArrayRef< Expr * > AdjustArgsNeedDevicePtr, ArrayRef< OMPInteropInfo > AppendArgs, SourceLocation AdjustArgsLoc, SourceLocation AppendArgsLoc, SourceRange SR)
Called on well-formed '#pragma omp declare variant' after parsing of the associated method/function.
void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer, VarDecl *OmpPrivParm)
Finish current declare reduction construct initializer.
DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen, ArrayRef< Expr * > Uniforms, ArrayRef< Expr * > Aligneds, ArrayRef< Expr * > Alignments, ArrayRef< Expr * > Linears, ArrayRef< unsigned > LinModifiers, ArrayRef< Expr * > Steps, SourceRange SR)
Called on well-formed '#pragma omp declare simd' after parsing of the associated method/function.
OMPClause * ActOnOpenMPAlignClause(Expr *Alignment, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'align' clause.
DeclGroupPtrTy ActOnOpenMPDeclareMapperDirective(Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType, SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS, Expr *MapperVarRef, ArrayRef< OMPClause * > Clauses, Decl *PrevDeclInScope=nullptr)
Called on start of '#pragma omp declare mapper'.
void AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI, ParameterABI abi)
RAII object used to change the argument pack substitution index within a Sema object.
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
CXXSpecialMemberKind asSpecialMember() const
A helper class for building up ExtParameterInfos.
Records and restores the CurFPFeatures state on entry/exit of compound statements.
RAII class used to indicate that we are performing provisional semantic analysis to determine the val...
Sema - This implements semantic analysis and AST building for C.
MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl)
VarTemplateSpecializationDecl * BuildVarTemplateInstantiation(VarTemplateDecl *VarTemplate, VarDecl *FromVar, const TemplateArgumentList *PartialSpecArgs, const TemplateArgumentListInfo &TemplateArgsInfo, SmallVectorImpl< TemplateArgument > &Converted, SourceLocation PointOfInstantiation, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *StartingScope=nullptr)
bool SubstTypeConstraint(TemplateTypeParmDecl *Inst, const TypeConstraint *TC, const MultiLevelTemplateArgumentList &TemplateArgs, bool EvaluateConstraint)
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R=nullptr, const UsingDecl *UD=nullptr)
Checks that the given nested-name qualifier used in a using decl in the current context is appropriat...
DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD)
Determine the kind of defaulting that would be done for a given function.
bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, std::optional< unsigned > &NumExpansions)
Determine whether we could expand a pack expansion with the given set of parameter packs into separat...
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupUsingDeclName
Look up all declarations in a scope with the given name, including resolved using declarations.
@ LookupRedeclarationWithLinkage
Look up an ordinary name that is going to be redeclared as a name with linkage.
Decl * ActOnSkippedFunctionBody(Decl *Decl)
Decl * BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *AssertMessageExpr, SourceLocation RParenLoc, bool Failed)
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, std::optional< unsigned > NumExpansions, bool ExpectParameterPack, bool EvaluateConstraints=true)
NamedDecl * FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, bool FindingInstantiatedContext=false)
Find the instantiation of the given declaration within the current instantiation.
MemInitResult BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, Expr *Init, CXXRecordDecl *ClassDecl, SourceLocation EllipsisLoc)
bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion)
AddAlignedAttr - Adds an aligned attribute to a particular declaration.
AccessResult CheckFriendAccess(NamedDecl *D)
Checks access to the target of a friend declaration.
const TranslationUnitKind TUKind
The kind of translation unit we are processing.
bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation, NamedDecl *Instantiation, bool InstantiatedFromMember, const NamedDecl *Pattern, const NamedDecl *PatternDef, TemplateSpecializationKind TSK, bool Complain=true)
Determine whether we would be unable to instantiate this template (because it either has no definitio...
void InstantiateExceptionSpec(SourceLocation PointOfInstantiation, FunctionDecl *Function)
void AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, Expr *OE)
AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular declaration.
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
bool TemplateParameterListsAreEqual(const TemplateCompareNewDeclInfo &NewInstFrom, TemplateParameterList *New, const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
void CheckOverrideControl(NamedDecl *D)
CheckOverrideControl - Check C++11 override control semantics.
llvm::DenseSet< std::pair< Decl *, unsigned > > InstantiatingSpecializations
Specializations whose definitions are currently being instantiated.
void deduceOpenCLAddressSpace(ValueDecl *decl)
PragmaStack< FPOptionsOverride > FpPragmaStack
FunctionDecl * InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD, const TemplateArgumentList *Args, SourceLocation Loc, CodeSynthesisContext::SynthesisKind CSC=CodeSynthesisContext::ExplicitTemplateArgumentSubstitution)
Instantiate (or find existing instantiation of) a function template with a given set of template argu...
bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec)
tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
ExprResult SubstInitializer(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs, bool CXXDirectInit)
MemInitResult BuildMemberInitializer(ValueDecl *Member, Expr *Init, SourceLocation IdLoc)
UsingShadowDecl * BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD, NamedDecl *Target, UsingShadowDecl *PrevDecl)
Builds a shadow declaration corresponding to a 'using' declaration.
void CheckThreadLocalForLargeAlignment(VarDecl *VD)
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
LateParsedTemplateMapT LateParsedTemplateMap
bool SubstExprs(ArrayRef< Expr * > Exprs, bool IsCall, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< Expr * > &Outputs)
Substitute the given template arguments into a list of expressions, expanding pack expansions if requ...
void CheckTemplatePartialSpecialization(ClassTemplatePartialSpecializationDecl *Partial)
StmtResult SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs)
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc, TemplateDecl *PrimaryTemplate, unsigned NumExplicitArgs, ArrayRef< TemplateArgument > Args)
Check the non-type template arguments of a class template partial specialization according to C++ [te...
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
DiagnosticsEngine & getDiagnostics() const
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, std::optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
void InstantiateMemInitializers(CXXConstructorDecl *New, const CXXConstructorDecl *Tmpl, const MultiLevelTemplateArgumentList &TemplateArgs)
void CleanupVarDeclMarking()
ASTContext & getASTContext() const
TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, bool AllowDeducedTST=false)
Perform substitution on the type T with a given set of template arguments.
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord)
Add gsl::Pointer attribute to std::container::iterator.
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation, bool IsUsingIfExists)
Builds a using declaration.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool SubstTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentListInfo &Outputs)
void HandleDependentAccessCheck(const DependentDiagnostic &DD, const MultiLevelTemplateArgumentList &TemplateArgs)
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
NamedReturnInfo getNamedReturnInfo(Expr *&E, SimplerImplicitMoveMode Mode=SimplerImplicitMoveMode::Normal)
Determine whether the given expression might be move-eligible or copy-elidable in either a (co_)retur...
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
const LangOptions & getLangOpts() const
void AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name, bool InInstantiation=false)
AddModeAttr - Adds a mode attribute to a particular declaration.
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
const LangOptions & LangOpts
void InstantiateClassMembers(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiates the definitions of all of the member of the given class, which is an instantiation of a ...
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, bool UpdateArgsWithConversions=true, bool *ConstraintsNotSatisfied=nullptr, bool PartialOrderingTTP=false)
Check that the given template arguments can be provided to the given template, converting the argumen...
void PerformPendingInstantiations(bool LocalOnly=false)
Performs template instantiation for all implicit template instantiations we have seen until this poin...
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr, FnBodyKind BodyKind=FnBodyKind::Other)
VarTemplateSpecializationDecl * CompleteVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiates a variable template specialization by completing it with appropriate type information an...
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn)
Perform semantic checking of a new function declaration.
FieldDecl * CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitfieldWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D=nullptr)
Build a new FieldDecl and check its well-formedness.
void updateAttrsForLateParsedTemplate(const Decl *Pattern, Decl *Inst)
Update instantiation attributes after template was late parsed.
bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange)
Mark the given method pure.
void InstantiateVariableInitializer(VarDecl *Var, VarDecl *OldVar, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the initializer of a variable.
SmallVector< PendingImplicitInstantiation, 1 > LateParsedInstantiations
Queue of implicit template instantiations that cannot be performed eagerly.
DeclarationNameInfo SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, const MultiLevelTemplateArgumentList &TemplateArgs)
Do template substitution on declaration name info.
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
const VarDecl * getCopyElisionCandidate(NamedReturnInfo &Info, QualType ReturnType)
Updates given NamedReturnInfo's move-eligible and copy-elidable statuses, considering the function re...
bool RequireCompleteEnumDecl(EnumDecl *D, SourceLocation L, CXXScopeSpec *SS=nullptr)
Require that the EnumDecl is completed with its enumerators defined or instantiated.
void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI, Expr *ParamExpr)
AddAllocAlignAttr - Adds an alloc_align attribute to a particular declaration.
void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Annot, MutableArrayRef< Expr * > Args)
AddAnnotationAttr - Adds an annotation Annot with Args arguments to D.
bool usesPartialOrExplicitSpecialization(SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec)
std::optional< unsigned > getNumArgumentsInExpansion(QualType T, const MultiLevelTemplateArgumentList &TemplateArgs)
Determine the number of arguments in the given pack expansion type.
ExplicitSpecifier instantiateExplicitSpecifier(const MultiLevelTemplateArgumentList &TemplateArgs, ExplicitSpecifier ES)
bool SubstParmTypes(SourceLocation Loc, ArrayRef< ParmVarDecl * > Params, const FunctionProtoType::ExtParameterInfo *ExtParamInfos, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< QualType > &ParamTypes, SmallVectorImpl< ParmVarDecl * > *OutParams, ExtParameterInfoBuilder &ParamInfos)
Substitute the given template arguments into the given set of parameters, producing the set of parame...
bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous)
Perform semantic checking on a newly-created variable declaration.
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
bool CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Target, const LookupResult &PreviousDecls, UsingShadowDecl *&PrevShadow)
Determines whether to create a using shadow decl for a particular decl, given the set of decls existi...
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T)
Mark all of the declarations referenced within a particular AST node as referenced.
bool CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind ActOnExplicitInstantiationNewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPtOfInstantiation, bool &SuppressNew)
Diagnose cases where we have an explicit template specialization before/after an explicit template in...
SourceManager & getSourceManager() const
FunctionDecl * SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD, FunctionDecl *Spaceship)
Substitute the name and return type of a defaulted 'operator<=>' to form an implicit 'operator=='.
void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDecl, ArrayRef< Decl * > Elements, Scope *S, const ParsedAttributesView &Attr)
Decl * SubstDecl(Decl *D, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs)
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI, SourceLocation Loc)
Check that the type of a non-type template parameter is well-formed.
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
void keepInLifetimeExtendingContext()
keepInLifetimeExtendingContext - Pull down InLifetimeExtendingContext flag from previous context.
void ActOnMemInitializers(Decl *ConstructorDecl, SourceLocation ColonLoc, ArrayRef< CXXCtorInitializer * > MemInits, bool AnyErrors)
ActOnMemInitializers - Handle the member initializers for a constructor.
TemplateParameterList * SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs, bool EvaluateConstraints=true)
void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI, Expr *MaxThreads, Expr *MinBlocks, Expr *MaxBlocks)
AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular declaration.
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don't have one.
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor)
In the MS ABI, we need to instantiate default arguments of dllexported default constructors along wit...
RedeclarationKind forRedeclarationInCurContext() const
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
bool SubstTemplateArgument(const TemplateArgumentLoc &Input, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentLoc &Output, SourceLocation Loc={}, const DeclarationName &Entity={})
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given function from its template.
bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Previous)
Checks that the given using declaration is not an invalid redeclaration.
bool SubstDefaultArgument(SourceLocation Loc, ParmVarDecl *Param, const MultiLevelTemplateArgumentList &TemplateArgs, bool ForCallExpr=false)
Substitute the given template arguments into the default argument.
void InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
EnumConstantDecl * CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *val)
void DiagnoseUnusedNestedTypedefs(const RecordDecl *D)
bool hasUncompilableErrorOccurred() const
Whether uncompilable error has occurred.
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed.
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
void CheckStaticLocalForDllExport(VarDecl *VD)
Check if VD needs to be dllexport/dllimport due to being in a dllexport/import function.
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
LateTemplateParserCB * LateTemplateParser
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
SourceManager & SourceMgr
bool CheckAlignasTypeArgument(StringRef KWName, TypeSourceInfo *TInfo, SourceLocation OpLoc, SourceRange R)
NamedDecl * BuildUsingPackDecl(NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl * > Expansions)
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc, StringLiteral *Message=nullptr)
NamespaceDecl * getStdNamespace() const
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
@ TPC_FriendFunctionTemplate
@ TPC_FriendFunctionTemplateDefinition
void DiagnoseUnusedDecl(const NamedDecl *ND)
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
void ActOnUninitializedDecl(Decl *dcl)
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
void BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar, const MultiLevelTemplateArgumentList &TemplateArgs, LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner, LocalInstantiationScope *StartingScope, bool InstantiatingVarTemplate=false, VarTemplateSpecializationDecl *PrevVTSD=nullptr)
BuildVariableInstantiation - Used after a new variable has been created.
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC, SkipBodyInfo *SkipBody=nullptr)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
void CheckAlignasUnderalignment(Decl *D)
std::pair< ValueDecl *, SourceLocation > PendingImplicitInstantiation
An entity for which implicit template instantiation is required.
DeclContext * FindInstantiatedContext(SourceLocation Loc, DeclContext *DC, const MultiLevelTemplateArgumentList &TemplateArgs)
Finds the instantiation of the given declaration context within the current instantiation.
bool isIncompatibleTypedef(const TypeDecl *Old, TypedefNameDecl *New)
void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E)
AddAlignValueAttr - Adds an align_value attribute to a particular declaration.
ArrayRef< sema::FunctionScopeInfo * > getFunctionScopes() const
void PerformDependentDiagnostics(const DeclContext *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
bool checkStringLiteralArgumentAttr(const AttributeCommonInfo &CI, const Expr *E, StringRef &Str, SourceLocation *ArgLocation=nullptr)
Check if the argument E is a ASCII string literal.
bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy, bool IsFixed, const EnumDecl *Prev)
Check whether this is a valid redeclaration of a previous enumeration.
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr, bool SkipImmediateInvocations=true)
Instantiate or parse a C++ default argument expression as necessary.
ASTMutationListener * getASTMutationListener() const
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
TypeSourceInfo * SubstFunctionDeclType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext, Qualifiers ThisTypeQuals, bool EvaluateConstraints=true)
A form of SubstType intended specifically for instantiating the type of a FunctionDecl.
Encodes a location in the source.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
unsigned getExpansionLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
StringRef getFilename(SourceLocation SpellingLoc) const
Return the filename of the file containing a SourceLocation.
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
Represents a C++11 static_assert declaration.
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
Represents the declaration of a struct/union/class/enum.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
TypedefNameDecl * getTypedefNameForAnonDecl() const
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type?
TagKind getTagKind() const
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
A template argument list.
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Location wrapper for a TemplateArgument.
Represents a template argument.
@ Pack
The template argument is actually a parameter pack.
@ RewriteSpaceshipAsEqualEqual
void setEvaluateConstraints(bool B)
Decl * VisitDecl(Decl *D)
Decl * VisitVarDecl(VarDecl *D, bool InstantiatingVarTemplate, ArrayRef< BindingDecl * > *Bindings=nullptr)
bool InitMethodInstantiation(CXXMethodDecl *New, CXXMethodDecl *Tmpl)
Initializes common fields of an instantiated method declaration (New) from the corresponding fields o...
bool InitFunctionInstantiation(FunctionDecl *New, FunctionDecl *Tmpl)
Initializes the common fields of an instantiation function declaration (New) from the corresponding f...
VarTemplatePartialSpecializationDecl * InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a variable template partial specialization.
void adjustForRewrite(RewriteKind RK, FunctionDecl *Orig, QualType &T, TypeSourceInfo *&TInfo, DeclarationNameInfo &NameInfo)
TypeSourceInfo * SubstFunctionType(FunctionDecl *D, SmallVectorImpl< ParmVarDecl * > &Params)
Decl * VisitVarTemplateSpecializationDecl(VarTemplateDecl *VarTemplate, VarDecl *FromVar, const TemplateArgumentListInfo &TemplateArgsInfo, ArrayRef< TemplateArgument > Converted, VarTemplateSpecializationDecl *PrevDecl=nullptr)
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
Decl * VisitFunctionDecl(FunctionDecl *D, TemplateParameterList *TemplateParams, RewriteKind RK=RewriteKind::None)
Normal class members are of more specific types and therefore don't make it here.
Decl * VisitCXXMethodDecl(CXXMethodDecl *D, TemplateParameterList *TemplateParams, RewriteKind RK=RewriteKind::None)
Decl * InstantiateTypeAliasTemplateDecl(TypeAliasTemplateDecl *D)
Decl * VisitBaseUsingDecls(BaseUsingDecl *D, BaseUsingDecl *Inst, LookupResult *Lookup)
bool SubstQualifier(const DeclaratorDecl *OldDecl, DeclaratorDecl *NewDecl)
TemplateParameterList * SubstTemplateParams(TemplateParameterList *List)
Instantiates a nested template parameter list in the current instantiation context.
Decl * InstantiateTypedefNameDecl(TypedefNameDecl *D, bool IsTypeAlias)
ClassTemplatePartialSpecializationDecl * InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl *ClassTemplate, ClassTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a class template partial specialization.
bool SubstDefaultedFunction(FunctionDecl *New, FunctionDecl *Tmpl)
The base class of all kinds of template declarations (e.g., class, function, etc.).
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
bool isNull() const
Determine whether this template name is NULL.
A template parameter object.
Stores a list of template parameters for a TemplateDecl and its derived classes.
SourceRange getSourceRange() const LLVM_READONLY
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
ArrayRef< NamedDecl * > asArray()
SourceLocation getTemplateLoc() const
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, bool Typename, TemplateParameterList *Params)
Declaration of a template type parameter.
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter.
The top declaration context.
Represents the declaration of a typedef-name via a C++11 alias-declaration.
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Declaration of an alias template.
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
void setTypeForDecl(const Type *TD)
const Type * getTypeForDecl() const
SourceLocation getBeginLoc() const LLVM_READONLY
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
Base wrapper for a particular "section" of type source info.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
TypeLoc IgnoreParens() const
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
AutoTypeLoc getContainedAutoTypeLoc() const
Get the typeloc of an AutoType whose type will be deduced for a variable with an initializer of this ...
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
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.
SourceLocation getNameLoc() const
void setNameLoc(SourceLocation Loc)
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isRValueReferenceType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isLValueReferenceType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool containsErrors() const
Whether this type is an error type.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isFunctionType() 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)
Base class for declarations which introduce a typedef-name.
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
This node is generated when a using-declaration that was annotated with attribute((using_if_exists)) ...
static UnresolvedUsingIfExistsDecl * Create(ASTContext &Ctx, DeclContext *DC, SourceLocation Loc, DeclarationName Name)
Represents a dependent using declaration which was marked with typename.
SourceLocation getTypenameLoc() const
Returns the source location of the 'typename' keyword.
Represents a dependent using declaration which was not marked with typename.
Represents a C++ using-declaration.
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
Represents C++ using-directive.
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Represents a C++ using-enum-declaration.
static UsingEnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, SourceLocation EnumL, SourceLocation NameL, TypeSourceInfo *EnumType)
Represents a pack of using declarations that a single using-declarator pack-expanded into.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
void setType(QualType newType)
Represents a variable declaration or definition.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
void setObjCForDecl(bool FRD)
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
void setCXXForRangeDecl(bool FRD)
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
void setInitStyle(InitializationStyle Style)
InitializationStyle getInitStyle() const
The style of initialization for this declaration.
void setInitCapture(bool IC)
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
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 isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
@ CallInit
Call-style initialization (C++98)
bool isObjCForDecl() const
Determine whether this variable is a for-loop declaration for a for-in statement in Objective-C.
void setPreviousDeclInSameBlockScope(bool Same)
bool isInlineSpecified() const
bool isStaticDataMember() const
Determines whether this is a static data member.
VarDecl * getTemplateInstantiationPattern() const
Retrieve the variable declaration from which this variable could be instantiated, if it is an instant...
bool isCXXForRangeDecl() const
Determine whether this variable is the for-range-declaration in a C++0x for-range statement.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
bool mightBeUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value might be usable in a constant expression, according to the re...
void setInlineSpecified()
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
void setTSCSpec(ThreadStorageClassSpecifier TSC)
void setNRVOVariable(bool NRVO)
bool isInline() const
Whether this variable is (C++1z) inline.
ThreadStorageClassSpecifier getTSCSpec() const
const Expr * getInit() const
void setConstexpr(bool IC)
void setDescribedVarTemplate(VarTemplateDecl *Template)
bool isDirectInit() const
Whether the initializer is a direct-initializer (list or call).
StorageClass getStorageClass() const
Returns the storage class as written in the source.
void setImplicitlyInline()
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration's previous declaration was declared in the same block ...
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
TemplateSpecializationKind getTemplateSpecializationKindForInstantiation() const
Get the template specialization kind of this variable for the purposes of template instantiation.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
Declaration of a variable template.
void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D, void *InsertPos)
Insert the specified partial specialization knowing that it is not already in.
VarTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, TemplateParameterList *TPL, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
VarTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(VarTemplatePartialSpecializationDecl *D)
Find a variable template partial specialization which was instantiated from the given member partial ...
static VarTemplatePartialSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
void setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec)
Represents a variable template specialization, which refers to a variable template with a given set o...
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)
Set the template argument list as written in the sources.
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Retrieve the template argument list as written in the sources, if any.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...
static VarTemplateSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
void setCompleteDefinition()
QualType FunctionType
BlockType - The function type of the block, if one was given.
void addCapture(ValueDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
Provides information about an attempted template argument deduction, whose success or failure was des...
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
bool NE(InterpState &S, CodePtr OpPC)
Attr * instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
Attr * instantiateTemplateAttributeForDecl(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
The JSON file list parser is used to communicate input to InstallAPI.
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
@ Rewrite
We are substituting template parameters for (typically) other template parameters in order to rewrite...
StorageClass
Storage classes.
@ Property
The type of a property.
@ Result
The result type of a method or function.
@ TU_Prefix
The translation unit is a prefix to a translation unit, and is not complete.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
const FunctionProtoType * T
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
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.
@ Other
Other implicit parameter.
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
@ EST_Uninstantiated
not instantiated yet
@ EST_None
no exception specification
@ EST_BasicNoexcept
noexcept
@ EST_Unevaluated
not evaluated yet, for special member function
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
SourceLocation RAngleLoc
The source location of the right angle bracket ('>').
SourceLocation LAngleLoc
The source location of the left angle bracket ('<').
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
const DeclarationNameLoc & getInfo() const
Holds information about the various types of exception specification.
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
ExceptionSpecificationType Type
The kind of exception specification this is.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
FunctionType::ExtInfo ExtInfo
This structure contains most locations needed for by an OMPVarListClause.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
SynthesisKind
The kind of template instantiation we are performing.
@ BuildingDeductionGuides
We are building deduction guides for a class.
@ DeducedTemplateArgumentSubstitution
We are substituting template argument determined as part of template argument deduction for either a ...
A stack object to be created when performing template instantiation.
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
bool isAlreadyInstantiating() const
Determine whether we are already instantiating this specialization in some surrounding active instant...