34#include "llvm/Support/TimeProfiler.h"
45 return cast<CXXRecordDecl>(DC)->isLocalClass();
50template<
typename DeclT>
53 if (!OldDecl->getQualifierLoc())
56 assert((NewDecl->getFriendObjectKind() ||
57 !OldDecl->getLexicalDeclContext()->isDependentContext()) &&
58 "non-friend with qualified name defined in dependent context");
61 const_cast<DeclContext *
>(NewDecl->getFriendObjectKind()
62 ? NewDecl->getLexicalDeclContext()
63 : OldDecl->getLexicalDeclContext()));
72 NewDecl->setQualifierInfo(NewQualifierLoc);
78 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
83 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
87#include "clang/Sema/AttrTemplateInstantiate.inc"
91 const AlignedAttr *Aligned,
Decl *New,
bool IsPackExpansion) {
92 if (Aligned->isAlignmentExpr()) {
101 S.
SubstType(Aligned->getAlignmentType(), TemplateArgs,
104 Aligned->getLocation(),
105 Result->getTypeLoc().getSourceRange()))
113 const AlignedAttr *Aligned,
Decl *New) {
114 if (!Aligned->isPackExpansion()) {
120 if (Aligned->isAlignmentExpr())
126 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
129 bool Expand =
true, RetainExpansion =
false;
130 std::optional<unsigned> NumExpansions;
134 Unexpanded, TemplateArgs, Expand,
135 RetainExpansion, NumExpansions))
142 for (
unsigned I = 0; I != *NumExpansions; ++I) {
151 const AssumeAlignedAttr *Aligned,
Decl *New) {
156 Expr *E, *OE =
nullptr;
162 if (Aligned->getOffset()) {
174 const AlignValueAttr *Aligned,
Decl *New) {
185 const AllocAlignAttr *Align,
Decl *New) {
188 llvm::APInt(64, Align->getParamIndex().getSourceIndex()),
195 const AnnotateAttr *
Attr,
Decl *New) {
201 bool HasDelayedArgs =
Attr->delayedArgs_size();
210 false, TemplateArgs, Args))
213 StringRef Str =
Attr->getAnnotation();
214 if (HasDelayedArgs) {
215 if (Args.size() < 1) {
225 ActualArgs.insert(ActualArgs.begin(), Args.begin() + 1, Args.end());
226 std::swap(Args, ActualArgs);
234 Expr *Cond =
nullptr;
248 Cond = Converted.
get();
254 S.
Diag(A->
getLocation(), diag::err_attr_cond_never_constant_expr) << A;
255 for (
const auto &
P : Diags)
256 S.
Diag(
P.first,
P.second);
266 S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);
270 Cond, EIA->getMessage()));
277 S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);
282 DIA->getDiagnosticType(), DIA->getArgDependent(), New));
289 const CUDALaunchBoundsAttr &
Attr,
Decl *New) {
299 Expr *MinBlocks =
nullptr;
300 if (
Attr.getMinBlocks()) {
307 Expr *MaxBlocks =
nullptr;
308 if (
Attr.getMaxBlocks()) {
329 const OMPDeclareSimdDeclAttr &
Attr,
Decl *New) {
331 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
332 New = FTD->getTemplatedDecl();
333 auto *FD = cast<FunctionDecl>(New);
334 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
339 if (
auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
340 if (
auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
343 if (FD->getNumParams() > PVD->getFunctionScopeIndex())
344 Local.InstantiatedLocal(
345 PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
349 FD->isCXXInstanceMember());
365 if (
auto *E =
Attr.getSimdlen())
368 if (
Attr.uniforms_size() > 0) {
369 for(
auto *E :
Attr.uniforms()) {
373 Uniforms.push_back(Inst.
get());
377 auto AI =
Attr.alignments_begin();
378 for (
auto *E :
Attr.aligneds()) {
382 Aligneds.push_back(Inst.
get());
386 Alignments.push_back(Inst.
get());
390 auto SI =
Attr.steps_begin();
391 for (
auto *E :
Attr.linears()) {
395 Linears.push_back(Inst.
get());
399 Steps.push_back(Inst.
get());
402 LinModifiers.append(
Attr.modifiers_begin(),
Attr.modifiers_end());
405 Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps,
412 const OMPDeclareVariantAttr &
Attr,
Decl *New) {
414 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
415 New = FTD->getTemplatedDecl();
416 auto *FD = cast<FunctionDecl>(New);
417 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
419 auto &&SubstExpr = [FD, ThisContext, &S, &TemplateArgs](
Expr *E) {
420 if (
auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
421 if (
auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
424 if (FD->getNumParams() > PVD->getFunctionScopeIndex())
425 Local.InstantiatedLocal(
426 PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
430 FD->isCXXInstanceMember());
436 auto &&Subst = [&SubstExpr, &S](
Expr *E) {
446 if (
Expr *E =
Attr.getVariantFuncRef()) {
451 VariantFuncRef = Subst(E);
457 TI = *
Attr.getTraitInfos();
460 auto SubstScoreOrConditionExpr = [&S, Subst](
Expr *&E,
bool) {
475 Expr *E = VariantFuncRef.
get();
479 std::optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
487 E = DeclVarData->second;
488 FD = DeclVarData->first;
490 if (
auto *VariantDRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts())) {
491 if (
auto *VariantFD = dyn_cast<FunctionDecl>(VariantDRE->getDecl())) {
492 if (
auto *VariantFTD = VariantFD->getDescribedFunctionTemplate()) {
493 if (!VariantFTD->isThisDeclarationADefinition())
504 SubstFD->getType(), FD->getType(),
512 SubstFD->setInstantiationIsPending(!SubstFD->isDefined());
516 SubstFD->getLocation(),
526 for (
Expr *E :
Attr.adjustArgsNothing()) {
530 NothingExprs.push_back(ER.
get());
532 for (
Expr *E :
Attr.adjustArgsNeedDevicePtr()) {
536 NeedDevicePtrExprs.push_back(ER.
get());
540 AppendArgs.emplace_back(II.IsTarget, II.IsTargetSync);
544 FD, E, TI, NothingExprs, NeedDevicePtrExprs, AppendArgs,
SourceLocation(),
550 const AMDGPUFlatWorkGroupSizeAttr &
Attr,
Decl *New) {
573 Expr *Cond =
nullptr;
581 Cond = SubstResult.
get();
591 const AMDGPUWavesPerEUAttr &
Attr,
Decl *New) {
601 Expr *MaxExpr =
nullptr;
602 if (
auto Max =
Attr.getMax()) {
614 const AMDGPUMaxNumWorkGroupsAttr &
Attr,
Decl *New) {
640 const SYCLKernelAttr &
Attr,
Decl *New) {
650 if (
const auto *PNA = dyn_cast<PreferredNameAttr>(A)) {
652 const auto *RD = cast<CXXRecordDecl>(D);
656 for (
const auto *ExistingPNA : D->
specific_attrs<PreferredNameAttr>())
658 PNA->getTypedefType()))
663 if (
const auto *BA = dyn_cast<BuiltinAttr>(A)) {
665 switch (BA->getID()) {
666 case Builtin::BIforward:
676 case Builtin::BImove:
677 case Builtin::BImove_if_noexcept:
693 const HLSLParamModifierAttr *
Attr,
Decl *New) {
703 if (
NamedDecl *ND = dyn_cast<NamedDecl>(New)) {
707 for (
const auto *TmplAttr : Tmpl->
attrs()) {
714 *
this, dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()),
718 TmplAttr,
Context, *
this, TemplateArgs);
728 case clang::attr::CFConsumed:
730 case clang::attr::OSConsumed:
732 case clang::attr::NSConsumed:
735 llvm_unreachable(
"Wrong argument supplied");
743 for (
const auto *TmplAttr : Tmpl->
attrs()) {
748 const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
749 if (Aligned && Aligned->isAlignmentDependent()) {
754 if (
const auto *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr)) {
759 if (
const auto *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr)) {
764 if (
const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) {
769 if (
const auto *Annotate = dyn_cast<AnnotateAttr>(TmplAttr)) {
774 if (
const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
776 cast<FunctionDecl>(New));
780 if (
const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
782 cast<FunctionDecl>(New));
786 if (
const auto *CUDALaunchBounds =
787 dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
789 *CUDALaunchBounds, New);
793 if (
const auto *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
798 if (
const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
803 if (
const auto *OMPAttr = dyn_cast<OMPDeclareVariantAttr>(TmplAttr)) {
808 if (
const auto *AMDGPUFlatWorkGroupSize =
809 dyn_cast<AMDGPUFlatWorkGroupSizeAttr>(TmplAttr)) {
811 *
this, TemplateArgs, *AMDGPUFlatWorkGroupSize, New);
814 if (
const auto *AMDGPUFlatWorkGroupSize =
815 dyn_cast<AMDGPUWavesPerEUAttr>(TmplAttr)) {
817 *AMDGPUFlatWorkGroupSize, New);
820 if (
const auto *AMDGPUMaxNumWorkGroups =
821 dyn_cast<AMDGPUMaxNumWorkGroupsAttr>(TmplAttr)) {
823 *
this, TemplateArgs, *AMDGPUMaxNumWorkGroups, New);
826 if (
const auto *ParamAttr = dyn_cast<HLSLParamModifierAttr>(TmplAttr)) {
833 if (TmplAttr->getKind() == attr::DLLExport ||
834 TmplAttr->getKind() == attr::DLLImport) {
835 if (New->
hasAttr<DLLExportAttr>() || New->
hasAttr<DLLImportAttr>()) {
840 if (
const auto *ABIAttr = dyn_cast<ParameterABIAttr>(TmplAttr)) {
845 if (isa<NSConsumedAttr>(TmplAttr) || isa<OSConsumedAttr>(TmplAttr) ||
846 isa<CFConsumedAttr>(TmplAttr)) {
852 if (
auto *A = dyn_cast<PointerAttr>(TmplAttr)) {
853 if (!New->
hasAttr<PointerAttr>())
858 if (
auto *A = dyn_cast<OwnerAttr>(TmplAttr)) {
859 if (!New->
hasAttr<OwnerAttr>())
864 if (
auto *A = dyn_cast<SYCLKernelAttr>(TmplAttr)) {
869 assert(!TmplAttr->isPackExpansion());
870 if (TmplAttr->isLateParsed() && LateAttrs) {
879 auto *ND = cast<NamedDecl>(New);
880 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
882 ND->isCXXInstanceMember());
885 *
this, TemplateArgs);
899 for (
const auto *
Attr : Pattern->
attrs()) {
900 if (
auto *A = dyn_cast<StrictFPAttr>(
Attr)) {
901 if (!Inst->
hasAttr<StrictFPAttr>())
918 DLLExportAttr *
Attr = Ctor->
getAttr<DLLExportAttr>();
921 for (
unsigned I = 0; I != NumParams; ++I) {
932template<
typename DeclT>
934 DeclT *
Result = D->getPreviousDecl();
939 if (
Result && isa<CXXRecordDecl>(D->getDeclContext()) &&
940 D->getLexicalDeclContext() !=
Result->getLexicalDeclContext())
948 llvm_unreachable(
"Translation units cannot be instantiated");
952 llvm_unreachable(
"HLSL buffer declarations cannot be instantiated");
957 llvm_unreachable(
"pragma comment cannot be instantiated");
960Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl(
962 llvm_unreachable(
"pragma comment cannot be instantiated");
967 llvm_unreachable(
"extern \"C\" context cannot be instantiated");
971 llvm_unreachable(
"GUID declaration cannot be instantiated");
974Decl *TemplateDeclInstantiator::VisitUnnamedGlobalConstantDecl(
976 llvm_unreachable(
"UnnamedGlobalConstantDecl cannot be instantiated");
979Decl *TemplateDeclInstantiator::VisitTemplateParamObjectDecl(
981 llvm_unreachable(
"template parameter objects cannot be instantiated");
985TemplateDeclInstantiator::VisitLabelDecl(
LabelDecl *D) {
993TemplateDeclInstantiator::VisitNamespaceDecl(
NamespaceDecl *D) {
994 llvm_unreachable(
"Namespaces cannot be instantiated");
1017 DI = SemaRef.
SubstType(DI, TemplateArgs,
1058 TagDecl *oldTag = oldTagType->getDecl();
1124 if (InstTemplate.isInvalid())
1128 if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
1130 if (!Found.
empty()) {
1131 PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.
front());
1144 if (PrevAliasTemplate)
1149 if (!PrevAliasTemplate)
1169 NewBindings.push_back(cast<BindingDecl>(VisitBindingDecl(OldBD)));
1172 auto *NewDD = cast_or_null<DecompositionDecl>(
1175 if (!NewDD || NewDD->isInvalidDecl())
1176 for (
auto *NewBD : NewBindings)
1177 NewBD->setInvalidDecl();
1187 bool InstantiatingVarTemplate,
1198 SemaRef.
Diag(D->
getLocation(), diag::err_variable_instantiates_to_function)
1231 StartingScope, InstantiatingVarTemplate);
1234 if (
auto *F = dyn_cast<FunctionDecl>(DC))
1235 RT = F->getReturnType();
1236 else if (isa<BlockDecl>(DC))
1240 llvm_unreachable(
"Unknown context type");
1277Decl *TemplateDeclInstantiator::VisitFieldDecl(
FieldDecl *D) {
1282 DI = SemaRef.
SubstType(DI, TemplateArgs,
1294 SemaRef.
Diag(D->
getLocation(), diag::err_field_instantiates_to_function)
1305 else if (BitWidth) {
1311 = SemaRef.
SubstExpr(BitWidth, TemplateArgs);
1316 BitWidth = InstantiatedBitWidth.
getAs<
Expr>();
1321 cast<RecordDecl>(Owner),
1334 SemaRef.
InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);
1336 if (
Field->hasAttrs())
1340 Field->setInvalidDecl();
1342 if (!
Field->getDeclName()) {
1347 if (
Parent->isAnonymousStructOrUnion() &&
1348 Parent->getRedeclContext()->isFunctionOrMethod())
1364 SemaRef.
Diag(D->
getLocation(), diag::err_property_is_variably_modified)
1368 DI = SemaRef.
SubstType(DI, TemplateArgs,
1380 SemaRef.
Diag(D->
getLocation(), diag::err_field_instantiates_to_function)
1409 for (
auto *PI : D->
chain()) {
1415 NamedChain[i++] = Next;
1418 QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
1421 {NamedChain, D->getChainingSize()});
1428 Owner->
addDecl(IndirectField);
1429 return IndirectField;
1444 InstTy = SemaRef.
SubstType(Ty, TemplateArgs,
1459 assert(ND &&
"friend decl must be a decl or a type!");
1466 if (!NewND)
return nullptr;
1485 = SemaRef.
SubstExpr(AssertExpr, TemplateArgs);
1491 if (InstantiatedMessageExpr.
isInvalid())
1499Decl *TemplateDeclInstantiator::VisitEnumDecl(
EnumDecl *D) {
1505 if (!Prev)
return nullptr;
1506 PrevDecl = cast<EnumDecl>(Prev);
1524 Enum->setIntegerTypeSourceInfo(NewTI);
1527 &&
"Dependent type without type source info");
1550 if (Def && Def != D) {
1557 SemaRef.
SubstType(TI->getType(), TemplateArgs,
1560 DefnUnderlying,
true,
Enum);
1581 Enum->startDefinition();
1592 if (
Expr *UninstValue = EC->getInitExpr()) {
1602 if (
Value.isInvalid()) {
1615 Enum->setInvalidDecl();
1622 Enum->addDecl(EnumConst);
1623 Enumerators.push_back(EnumConst);
1624 LastEnumConst = EnumConst;
1627 !
Enum->isScoped()) {
1640 llvm_unreachable(
"EnumConstantDecls can only occur within EnumDecls.");
1645 llvm_unreachable(
"BuiltinTemplateDecls cannot be instantiated.");
1677 if (!Found.
empty()) {
1678 PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.
front());
1679 if (PrevClassTemplate)
1692 SS.
Adopt(QualifierLoc);
1694 if (!DC)
return nullptr;
1708 if (R.isSingleResult()) {
1710 if (PrevClassTemplate)
1714 if (!PrevClassTemplate && QualifierLoc) {
1743 if (PrevClassTemplate) {
1774 if (!PrevClassTemplate)
1797 if (!PrevClassTemplate) {
1803 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1804 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1805 OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
1812TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
1824 = dyn_cast<ClassTemplateDecl>(Found.
front());
1825 if (!InstClassTemplate)
1837 "Only static data member templates are allowed.");
1853 PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.
front());
1859 if (!VarInst)
return nullptr;
1870 if (!PrevVarTemplate)
1880 if (!PrevVarTemplate) {
1886 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1887 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1888 OutOfLineVarPartialSpecs.push_back(
1889 std::make_pair(Inst, PartialSpecs[I]));
1895Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
1898 "Only static data member templates are allowed.");
1904 assert(!Found.
empty() &&
"Instantiation found nothing?");
1907 assert(InstVarTemplate &&
"Instantiation did not find a variable template?");
1947 assert(InstTemplate &&
1948 "VisitFunctionDecl/CXXMethodDecl didn't create a template!");
1966 return InstTemplate;
1975 if (!Prev)
return nullptr;
1976 PrevDecl = cast<CXXRecordDecl>(Prev);
1990 IsInjectedClassName);
1992 if (IsInjectedClassName)
2008 if (!IsInjectedClassName)
2014 Record->setObjectOfFriendDecl();
2018 Record->setAnonymousStructOrUnion(
true);
2056 LocalInstantiations.perform();
2061 if (IsInjectedClassName)
2062 assert(
Record->isInjectedClassName() &&
"Broken injected-class-name");
2080 if (OrigFunc->
getExtInfo() == NewFunc->getExtInfo())
2086 NewFunc->getParamTypes(), NewEPI);
2100 if (FunctionTemplate && !TemplateParams) {
2103 void *InsertPos =
nullptr;
2113 if (FunctionTemplate)
2118 bool MergeWithParentScope = (TemplateParams !=
nullptr) ||
2120 !(isa<Decl>(Owner) &&
2121 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
2125 if (
auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
2127 TemplateArgs, DGuide->getExplicitSpecifier());
2128 if (InstantiatedExplicitSpecifier.
isInvalid())
2138 if (TemplateParams && TemplateParams->
size()) {
2140 dyn_cast<TemplateTypeParmDecl>(TemplateParams->
asArray().back());
2141 if (LastParam && LastParam->isImplicit() &&
2142 LastParam->hasTypeConstraint()) {
2172 }
else if (isFriend && QualifierLoc) {
2174 SS.
Adopt(QualifierLoc);
2176 if (!DC)
return nullptr;
2189 if (
auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
2192 InstantiatedExplicitSpecifier, NameInfo,
T, TInfo,
2194 DGuide->getDeductionCandidateKind());
2201 TrailingRequiresClause);
2202 Function->setFriendConstraintRefersToEnclosingTemplate(
2211 Function->setQualifierInfo(QualifierLoc);
2225 Function->setLexicalDeclContext(LexicalDC);
2228 for (
unsigned P = 0;
P < Params.size(); ++
P)
2233 if (TrailingRequiresClause)
2234 Function->setTrailingRequiresClause(TrailingRequiresClause);
2236 if (TemplateParams) {
2255 Function->setDescribedFunctionTemplate(FunctionTemplate);
2263 }
else if (FunctionTemplate &&
2268 Function->setFunctionTemplateSpecialization(FunctionTemplate,
2277 }
else if (!isFriend) {
2281 Function->setInstantiatedFromDecl(D);
2287 FT->setObjectOfFriendDecl();
2293 bool IsExplicitSpecialization =
false;
2304 assert(isFriend &&
"dependent specialization info on "
2305 "non-member non-friend function?");
2309 if (
const auto *ArgsWritten = DFTSI->TemplateArgumentsAsWritten) {
2310 ExplicitArgs.
setLAngleLoc(ArgsWritten->getLAngleLoc());
2311 ExplicitArgs.
setRAngleLoc(ArgsWritten->getRAngleLoc());
2328 DFTSI->TemplateArgumentsAsWritten ? &ExplicitArgs :
nullptr,
2332 IsExplicitSpecialization =
true;
2340 ArgsWritten->getRAngleLoc());
2350 IsExplicitSpecialization =
true;
2351 }
else if (TemplateParams || !FunctionTemplate) {
2367 if (isFriend && !QualifierLoc) {
2387 if (
Function->isLocalExternDecl()) {
2389 if (!PVD->hasDefaultArg())
2395 Expr *UninstExpr = PVD->getUninstantiatedDefaultArg();
2398 { UninstExpr }, UninstExpr->
getType());
2400 PVD->setDefaultArg(ErrorResult.
get());
2406 IsExplicitSpecialization,
2407 Function->isThisDeclarationADefinition());
2413 if (isFriend && TemplateParams && FunctionTemplate->
getPreviousDecl()) {
2417 Function->isThisDeclarationADefinition()
2428 Function->getMemberSpecializationInfo()) {
2429 if (MSInfo->getPointOfInstantiation().isInvalid()) {
2431 MSInfo->setPointOfInstantiation(Loc);
2446 (TemplateParams ? cast<NamedDecl>(FunctionTemplate) :
Function);
2465 if (FunctionTemplate && !TemplateParams) {
2471 void *InsertPos =
nullptr;
2481 if (FunctionTemplate)
2486 bool MergeWithParentScope = (TemplateParams !=
nullptr) ||
2487 !(isa<Decl>(Owner) &&
2488 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
2496 unsigned NumTempParamLists = 0;
2498 TempParamLists.resize(NumTempParamLists);
2499 for (
unsigned I = 0; I != NumTempParamLists; ++I) {
2504 TempParamLists[I] = InstParams;
2510 const bool CouldInstantiate =
2511 InstantiatedExplicitSpecifier.getExpr() ==
nullptr ||
2512 !InstantiatedExplicitSpecifier.getExpr()->isValueDependent();
2516 if (CouldInstantiate ||
2520 TemplateArgs, InstantiatedExplicitSpecifier);
2522 if (InstantiatedExplicitSpecifier.isInvalid())
2534 if (cast<CXXRecordDecl>(D->
getParent())->isLambda() &&
2536 isa<CXXConstructorDecl, CXXDestructorDecl>(D)) {
2548 if (TemplateParams && TemplateParams->
size()) {
2550 dyn_cast<TemplateTypeParmDecl>(TemplateParams->
asArray().back());
2551 if (LastParam && LastParam->isImplicit() &&
2552 LastParam->hasTypeConstraint()) {
2577 SS.
Adopt(QualifierLoc);
2587 if (!DC)
return nullptr;
2606 InstantiatedExplicitSpecifier, Constructor->UsesFPIntrin(),
2607 Constructor->isInlineSpecified(),
false,
2609 TrailingRequiresClause);
2615 Destructor->getConstexprKind(), TrailingRequiresClause);
2624 Conversion->UsesFPIntrin(), Conversion->isInlineSpecified(),
2625 InstantiatedExplicitSpecifier, Conversion->getConstexprKind(),
2626 Conversion->getEndLoc(), TrailingRequiresClause);
2632 D->
getEndLoc(), TrailingRequiresClause);
2641 if (TemplateParams) {
2658 TemplateParams, Method);
2665 }
else if (FunctionTemplate) {
2672 }
else if (!isFriend) {
2681 if (NumTempParamLists)
2692 for (
unsigned P = 0;
P < Params.size(); ++
P)
2693 Params[
P]->setOwningFunction(Method);
2700 RedeclarationKind::ForExternalRedeclaration);
2702 bool IsExplicitSpecialization =
false;
2710 if (
const auto *ArgsWritten = DFTSI->TemplateArgumentsAsWritten) {
2711 ExplicitArgs.
setLAngleLoc(ArgsWritten->getLAngleLoc());
2712 ExplicitArgs.
setRAngleLoc(ArgsWritten->getRAngleLoc());
2728 Method, DFTSI->TemplateArgumentsAsWritten ? &ExplicitArgs :
nullptr,
2732 IsExplicitSpecialization =
true;
2738 ArgsWritten->getRAngleLoc());
2749 IsExplicitSpecialization =
true;
2750 }
else if (!FunctionTemplate || TemplateParams || isFriend) {
2777 for (
unsigned P = 0;
P < Params.size(); ++
P) {
2778 if (!Params[
P]->hasDefaultArg())
2784 Expr *UninstExpr = Params[
P]->getUninstantiatedDefaultArg();
2787 { UninstExpr }, UninstExpr->
getType());
2789 Params[
P]->setDefaultArg(ErrorResult.
get());
2795 IsExplicitSpecialization,
2808 if (FunctionTemplate)
2825 if (IsExplicitSpecialization && !isFriend)
2835 if (
auto *Constructor = dyn_cast<CXXConstructorDecl>(Method)) {
2836 if (Constructor->isDefaultConstructor() ||
2837 Constructor->isCopyOrMoveConstructor())
2845 if (FunctionTemplate) {
2853 }
else if (isFriend) {
2859 Record->makeDeclVisibleInContext(Method);
2870 if (Method->
hasAttr<UsedAttr>()) {
2871 if (
const auto *A = dyn_cast<CXXRecordDecl>(Owner)) {
2874 A->getMemberSpecializationInfo())
2875 Loc = MSInfo->getPointOfInstantiation();
2876 else if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(A))
2877 Loc = Spec->getPointOfInstantiation();
2903Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
2907 std::optional<unsigned> NumExpanded;
2911 assert(TC->getTemplateArgsAsWritten() &&
2912 "type parameter can only be an expansion when explicit arguments "
2918 for (
auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
2924 bool RetainExpansion =
false;
2926 cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
2929 TC->hasExplicitTemplateArgs() ?
2930 TC->getTemplateArgsAsWritten()->getRAngleLoc() :
2931 TC->getConceptNameInfo().getEndLoc()),
2932 Unexpanded, TemplateArgs, Expand, RetainExpansion, NumExpanded))
2951 EvaluateConstraints))
2959 if (InstantiatedDefaultArg)
2970Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
2976 bool IsExpandedParameterPack =
false;
2998 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2999 ExpandedParameterPackTypes.push_back(NewT);
3002 IsExpandedParameterPack =
true;
3017 bool RetainExpansion =
false;
3018 std::optional<unsigned> OrigNumExpansions =
3020 std::optional<unsigned> NumExpansions = OrigNumExpansions;
3022 Pattern.getSourceRange(),
3025 Expand, RetainExpansion,
3030 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3043 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
3044 ExpandedParameterPackTypes.push_back(NewT);
3050 IsExpandedParameterPack =
true;
3087 if (IsExpandedParameterPack)
3092 ExpandedParameterPackTypesAsWritten);
3100 if (AutoLoc.isConstrained()) {
3102 if (IsExpandedParameterPack)
3105 else if (
auto *Constraint = dyn_cast_if_present<CXXFoldExpr>(
3107 EllipsisLoc = Constraint->getEllipsisLoc();
3125 if (!
Value.isInvalid())
3139 for (
const auto &
P : *Params) {
3140 if (
P->isTemplateParameterPack())
3152TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
3159 bool IsExpandedParameterPack =
false;
3173 ExpandedParams.push_back(Expansion);
3176 IsExpandedParameterPack =
true;
3177 InstParams = TempParams;
3189 bool RetainExpansion =
false;
3190 std::optional<unsigned> NumExpansions;
3195 Expand, RetainExpansion,
3200 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3206 ExpandedParams.push_back(Expansion);
3212 IsExpandedParameterPack =
true;
3213 InstParams = TempParams;
3235 if (IsExpandedParameterPack)
3240 InstParams, ExpandedParams);
3298 for (
auto *Shadow : D->
shadows()) {
3302 NamedDecl *OldTarget = Shadow->getTargetDecl();
3303 if (
auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
3304 if (
auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
3305 OldTarget = BaseShadow;
3309 dyn_cast<UnresolvedUsingIfExistsDecl>(Shadow->getTargetDecl())) {
3311 SemaRef.
Context, Owner, EmptyD->getLocation(), EmptyD->getDeclName());
3314 Shadow->getLocation(), OldTarget, TemplateArgs));
3326 Shadow->getLocation(), OldPrev, TemplateArgs));
3329 nullptr, Inst, InstTarget, PrevDecl);
3332 if (isFunctionScope)
3339Decl *TemplateDeclInstantiator::VisitUsingDecl(
UsingDecl *D) {
3360 if (
auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.
CurContext))
3366 bool CheckRedeclaration = Owner->
isRecord();
3368 RedeclarationKind::ForVisibleRedeclaration);
3377 SS.
Adopt(QualifierLoc);
3378 if (CheckRedeclaration) {
3379 Prev.setHideTags(
false);
3444Decl *TemplateDeclInstantiator::VisitConstructorUsingShadowDecl(
3450template <
typename T>
3451Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
3452 T *D,
bool InstantiatingPackElement) {
3454 if (D->isPackExpansion() && !InstantiatingPackElement) {
3462 bool RetainExpansion =
false;
3463 std::optional<unsigned> NumExpansions;
3465 D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs,
3466 Expand, RetainExpansion, NumExpansions))
3471 assert(!RetainExpansion &&
3472 "should never need to retain an expansion for UsingPackDecl");
3478 return instantiateUnresolvedUsingDecl(D,
true);
3488 if (D->getDeclContext()->isFunctionOrMethod() && *NumExpansions > 1) {
3489 SemaRef.
Diag(D->getEllipsisLoc(),
3490 diag::err_using_decl_redeclaration_expansion);
3496 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3498 Decl *Slice = instantiateUnresolvedUsingDecl(D,
true);
3505 Expansions.push_back(cast<NamedDecl>(Slice));
3524 SS.
Adopt(QualifierLoc);
3531 bool InstantiatingSlice = D->getEllipsisLoc().isValid() &&
3536 bool IsUsingIfExists = D->template hasAttr<UsingIfExistsAttr>();
3538 nullptr, D->getAccess(), D->getUsingLoc(),
3539 TD, TypenameLoc, SS, NameInfo, EllipsisLoc,
3541 true, IsUsingIfExists);
3550Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
3552 return instantiateUnresolvedUsingDecl(D);
3555Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
3557 return instantiateUnresolvedUsingDecl(D);
3560Decl *TemplateDeclInstantiator::VisitUnresolvedUsingIfExistsDecl(
3562 llvm_unreachable(
"referring to unresolved decl out of UsingShadowDecl");
3570 Expansions.push_back(NewUD);
3581Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
3586 assert(isa<DeclRefExpr>(Var) &&
"threadprivate arg is not a DeclRefExpr");
3587 Vars.push_back(Var);
3603 assert(isa<DeclRefExpr>(Var) &&
"allocate arg is not a DeclRefExpr");
3604 Vars.push_back(Var);
3610 if (
auto *AC = dyn_cast<OMPAllocatorClause>(
C)) {
3615 NewE.
get(), AC->getBeginLoc(), AC->getLParenLoc(), AC->getEndLoc());
3616 }
else if (
auto *AC = dyn_cast<OMPAlignClause>(
C)) {
3621 NewE.
get(), AC->getBeginLoc(), AC->getLParenLoc(), AC->getEndLoc());
3626 Clauses.push_back(IC);
3631 if (Res.
get().isNull())
3633 return Res.
get().getSingleDecl();
3638 "Requires directive cannot be instantiated within a dependent context");
3641Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
3644 const bool RequiresInstantiation =
3649 if (RequiresInstantiation) {
3655 SubstReductionType = D->
getType();
3657 if (SubstReductionType.
isNull())
3661 bool IsCorrect =
true;
3663 std::pair<QualType, SourceLocation> ReductionTypes[] = {
3664 std::make_pair(SubstReductionType, D->
getLocation())};
3666 if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
3667 PrevDeclInScope = cast<OMPDeclareReductionDecl>(
3674 auto *NewDRD = cast<OMPDeclareReductionDecl>(DRD.get().getSingleDecl());
3676 Expr *SubstCombiner =
nullptr;
3677 Expr *SubstInitializer =
nullptr;
3684 cast<DeclRefExpr>(NewDRD->getCombinerIn())->getDecl());
3687 cast<DeclRefExpr>(NewDRD->getCombinerOut())->getDecl());
3688 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
3691 SubstCombiner = SemaRef.
SubstExpr(Combiner, TemplateArgs).
get();
3702 cast<DeclRefExpr>(NewDRD->getInitOrig())->getDecl());
3705 cast<DeclRefExpr>(NewDRD->getInitPriv())->getDecl());
3710 cast<VarDecl>(cast<DeclRefExpr>(D->
getInitPriv())->getDecl());
3711 IsCorrect = IsCorrect && OldPrivParm->hasInit();
3717 NewDRD, SubstInitializer, OmpPrivParm);
3719 IsCorrect = IsCorrect && SubstCombiner &&
3722 SubstInitializer) ||
3724 !SubstInitializer));
3735 const bool RequiresInstantiation =
3741 if (RequiresInstantiation) {
3749 if (SubstMapperTy.
isNull())
3753 if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
3754 PrevDeclInScope = cast<OMPDeclareMapperDecl>(
3758 bool IsCorrect =
true;
3770 cast<DeclRefExpr>(MapperVarRef.
get())->getDecl());
3771 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
3776 auto *OldC = cast<OMPMapClause>(
C);
3778 for (
Expr *OE : OldC->varlists()) {
3784 NewVars.push_back(NE);
3792 SS.
Adopt(NewQualifierLoc);
3798 OldC->getIteratorModifier(), OldC->getMapTypeModifiers(),
3799 OldC->getMapTypeModifiersLoc(), SS, NewNameInfo, OldC->getMapType(),
3800 OldC->isImplicitMapType(), OldC->getMapLoc(), OldC->getColonLoc(),
3802 Clauses.push_back(NewC);
3809 VN, D->
getAccess(), MapperVarRef.
get(), Clauses, PrevDeclInScope);
3810 Decl *NewDMD = DG.
get().getSingleDecl();
3815Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
3817 llvm_unreachable(
"Should not be met in templates");
3837 llvm_unreachable(
"There are only CXXRecordDecls in C++");
3841TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
3848 "can only instantiate an explicit specialization "
3849 "for a member class template");
3856 if (!InstClassTemplate)
3862 castAs<TemplateSpecializationTypeLoc>();
3866 for (
unsigned I = 0; I != Loc.
getNumArgs(); ++I)
3875 InstTemplateArgs,
false,
3876 SugaredConverted, CanonicalConverted,
3882 void *InsertPos =
nullptr;
3914 diag::note_previous_definition);
3922 D->
getLocation(), InstClassTemplate, CanonicalConverted, PrevDecl);
3977 assert(VarTemplate &&
3978 "A template specialization without specialized template?");
3983 if (!InstVarTemplate)
3989 VarTemplateArgsInfo.
setLAngleLoc(TemplateArgsInfo->getLAngleLoc());
3990 VarTemplateArgsInfo.
setRAngleLoc(TemplateArgsInfo->getRAngleLoc());
3993 TemplateArgs, VarTemplateArgsInfo))
4000 VarTemplateArgsInfo,
false,
4001 SugaredConverted, CanonicalConverted,
4006 void *InsertPos =
nullptr;
4020 InstVarTemplate, D, VarTemplateArgsInfo, CanonicalConverted, PrevDecl);
4037 SemaRef.
Diag(D->
getLocation(), diag::err_variable_instantiates_to_function)
4048 void *InsertPos =
nullptr;
4061 StartingScope,
false, PrevDecl);
4067 llvm_unreachable(
"@defs is not supported in Objective-C++");
4074 "cannot instantiate %0 yet");
4082 llvm_unreachable(
"Concept definitions cannot reside inside a template");
4085Decl *TemplateDeclInstantiator::VisitImplicitConceptSpecializationDecl(
4087 llvm_unreachable(
"Concept specializations cannot reside inside a template");
4097 llvm_unreachable(
"Unexpected decl");
4108 SubstD = Instantiator.Visit(D);
4123 SemaRef.
Context.
BoolTy, FPT->getParamTypes(), FPT->getExtProtoInfo());
4134 assert(OldLoc &&
"type of function is not a function type?");
4136 for (
unsigned I = 0, N = OldLoc.getNumParams(); I != N; ++I)
4137 NewLoc.
setParam(I, OldLoc.getParam(I));
4147 if (Spaceship->isInvalidDecl())
4159 if (
auto *MD = dyn_cast<CXXMethodDecl>(Spaceship)) {
4164 assert(Spaceship->getFriendObjectKind() &&
4165 "defaulted spaceship is neither a member nor a friend");
4175 cast<NamedDecl>(R), Spaceship->getBeginLoc());
4179 return cast_or_null<FunctionDecl>(R);
4193 unsigned N = L->
size();
4197 for (
auto &
P : *L) {
4199 Params.push_back(D);
4219 bool EvaluateConstraints) {
4266 ClassTemplate, PartialSpec->
getLocation(), InstTemplateArgs,
4267 false, SugaredConverted, CanonicalConverted))
4273 CanonicalConverted))
4278 void *InsertPos =
nullptr;
4318 SemaRef.
Diag(PartialSpec->
getLocation(), diag::err_partial_spec_redeclared)
4320 SemaRef.
Diag(PrevDecl->
getLocation(), diag::note_prev_partial_spec_here)
4331 ClassTemplate, CanonicalConverted, InstTemplateArgs, CanonType,
4347 return InstPartialSpec;
4391 VarTemplate, PartialSpec->
getLocation(), InstTemplateArgs,
4392 false, SugaredConverted, CanonicalConverted))
4398 CanonicalConverted))
4403 void *InsertPos =
nullptr;
4441 diag::err_var_partial_spec_redeclared)
4444 diag::note_var_prev_partial_spec_here);
4457 diag::err_variable_instantiates_to_function)
4485 LateAttrs, Owner, StartingScope);
4487 return InstPartialSpec;
4494 assert(OldTInfo &&
"substituting function without type source info");
4495 assert(Params.empty() &&
"parameter vector is non-empty at start");
4500 ThisContext = cast<CXXRecordDecl>(Owner);
4501 ThisTypeQuals = Method->getFunctionObjectParameterType().getQualifiers();
4506 ThisContext, ThisTypeQuals, EvaluateConstraints);
4512 if (NewTInfo != OldTInfo) {
4516 unsigned NewIdx = 0;
4517 for (
unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
4518 OldIdx != NumOldParams; ++OldIdx) {
4519 ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
4525 std::optional<unsigned> NumArgumentsInExpansion;
4527 NumArgumentsInExpansion =
4530 if (!NumArgumentsInExpansion) {
4534 Params.push_back(NewParam);
4535 Scope->InstantiatedLocal(OldParam, NewParam);
4538 Scope->MakeInstantiatedLocalArgPack(OldParam);
4539 for (
unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
4541 Params.push_back(NewParam);
4542 Scope->InstantiatedLocalPackArg(OldParam, NewParam);
4551 cast<FunctionProtoType>(OldProtoLoc.getType());
4552 for (
unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
4562 cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
4565 Params.push_back(Parm);
4582 TemplateArgs, ParamTypes, &Params,
4597 for (
auto *
decl : PatternDecl->
decls()) {
4598 if (!isa<VarDecl>(
decl) || isa<ParmVarDecl>(
decl))
4604 auto it = llvm::find_if(
Function->decls(), [&](
Decl *inst) {
4605 VarDecl *InstVD = dyn_cast<VarDecl>(inst);
4606 return InstVD && InstVD->isLocalVarDecl() &&
4607 InstVD->getIdentifier() == II;
4613 Scope.InstantiatedLocal(VD, *it);
4614 LSI->
addCapture(cast<VarDecl>(*it),
false,
false,
4623bool Sema::addInstantiatedParametersToScope(
4627 unsigned FParamIdx = 0;
4628 for (
unsigned I = 0, N = PatternDecl->
getNumParams(); I != N; ++I) {
4632 assert(FParamIdx < Function->getNumParams());
4650 Scope.InstantiatedLocal(PatternParam, FunctionParam);
4656 Scope.MakeInstantiatedLocalArgPack(PatternParam);
4657 std::optional<unsigned> NumArgumentsInExpansion =
4659 if (NumArgumentsInExpansion) {
4662 for (
unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
4675 Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
4707 false, std::nullopt,
4714 L->DefaultArgumentInstantiated(Param);
4736 Diag(PointOfInstantiation, diag::err_exception_spec_cycle) <<
Decl;
4748 false, std::nullopt,
4756 if (addInstantiatedParametersToScope(
Decl, Template,
Scope, TemplateArgs)) {
4790 if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
4791 ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
4792 if (isa<FunctionTemplateDecl>(ActiveInst.Entity)) {
4794 {ActiveInst.Entity->getCanonicalDecl(), ActiveInst.Kind});
4796 ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
4797 ActiveInst.Entity = New;
4803 assert(Proto &&
"Function template without prototype?");
4827 assert(NewProto &&
"Template instantiation without function prototype?");
4845 LateAttrs, StartingScope);
4861 if (isa<CXXDestructorDecl>(New) && SemaRef.
getLangOpts().CPlusPlus11)
4877 Lookups.reserve(DFI->getUnqualifiedLookups().size());
4878 bool AnyChanged =
false;
4881 DA.getDecl(), TemplateArgs);
4884 AnyChanged |= (D != DA.getDecl());
4942 bool DefinitionRequired,
4950 Function->getTemplateSpecializationKindForInstantiation();
4957 !DefinitionRequired)
4962 if (
Function->isDefined(ExistingDefn,
4976 assert(PatternDecl &&
"instantiating a non-template");
4979 Stmt *Pattern =
nullptr;
4981 Pattern = PatternDef->
getBody(PatternDef);
4982 PatternDecl = PatternDef;
4984 PatternDef =
nullptr;
4990 Function->getInstantiatedFromMemberFunction(),
4991 PatternDecl, PatternDef, TSK,
4992 DefinitionRequired)) {
4993 if (DefinitionRequired)
4996 (
Function->isConstexpr() && !Recursive)) {
5000 Function->setInstantiationIsPending(
true);
5002 std::make_pair(
Function, PointOfInstantiation));
5006 Diag(PointOfInstantiation, diag::warn_func_template_missing)
5010 Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
5021 Function->setInstantiationIsPending(
true);
5023 std::make_pair(
Function, PointOfInstantiation));
5027 llvm::TimeTraceScope TimeScope(
"InstantiateFunction", [&]() {
5029 llvm::raw_string_ostream
OS(Name);
5054 "missing LateParsedTemplate");
5056 Pattern = PatternDecl->
getBody(PatternDecl);
5063 "unexpected kind of function template definition");
5078 for (
auto *D =
Function->getMostRecentDecl(); ;
5080 D->setImplicitlyInline();
5090 "instantiating function definition");
5094 Function->setVisibleDespiteOwningModule();
5108 ThisTypeQuals = Method->getMethodQualifiers();
5118 bool MergeWithParentScope =
false;
5120 MergeWithParentScope =
5121 Rec->isLocalClass() && !
Function->isFunctionTemplateSpecialization();
5124 auto RebuildTypeSourceInfoForDefaultSpecialMembers = [&]() {
5130 "Special member needs to be defaulted");
5138 auto *NewRec = dyn_cast<CXXRecordDecl>(
Function->getDeclContext());
5139 const auto *PatternRec =
5141 if (!NewRec || !PatternRec)
5143 if (!PatternRec->isLambda())
5146 struct SpecialMemberTypeInfoRebuilder
5166 getDerived().TransformDecl(TL.
getNameLoc(),
T->getDecl()));
5168 return Base::TransformRecordType(TLB, TL);
5170 QualType Result = getDerived().RebuildRecordType(NewDecl);
5171 if (Result.isNull())
5178 } IR{*
this, PatternRec, NewRec};
5181 assert(NewSI &&
"Type Transform failed?");
5183 Function->setTypeSourceInfo(NewSI);
5187 assert(NewParmSI &&
"Type transformation failed.");
5193 RebuildTypeSourceInfoForDefaultSpecialMembers();
5198 std::nullopt,
false, PatternDecl);
5216 if (addInstantiatedParametersToScope(
Function, PatternDecl,
Scope,
5233 Ctor->isDefaultConstructor()) {
5239 Body =
SubstStmt(Pattern, TemplateArgs);
5251 Listener->FunctionDefinitionInstantiated(
Function);
5261 LocalInstantiations.
perform();
5263 GlobalInstantiations.perform();
5289 bool IsMemberSpec =
false;
5291 if (
auto *PartialSpec =
5292 dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar)) {
5293 assert(PartialSpecArgs);
5294 IsMemberSpec = PartialSpec->isMemberSpecialization();
5296 PartialSpec, PartialSpecArgs->
asArray(),
false);
5299 IsMemberSpec =
VarTemplate->isMemberSpecialization();
5311 return cast_or_null<VarTemplateSpecializationDecl>(
5313 VarTemplate, FromVar, TemplateArgsInfo, Converted));
5322 "don't have a definition to instantiate from");
5354 bool InstantiatingVarTemplate,
5358 bool InstantiatingVarTemplatePartialSpec =
5359 isa<VarTemplatePartialSpecializationDecl>(OldVar) &&
5360 isa<VarTemplatePartialSpecializationDecl>(NewVar);
5363 bool InstantiatingSpecFromTemplate =
5364 isa<VarTemplateSpecializationDecl>(NewVar) &&
5366 isa<VarTemplatePartialSpecializationDecl>(OldVar));
5389 if (OldVar->
isUsed(
false))
5411 }
else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
5414 }
else if (PrevDeclForVarTemplateSpecialization) {
5415 Previous.addDecl(PrevDeclForVarTemplateSpecialization);
5419 if (!InstantiatingVarTemplate) {
5437 !InstantiatingSpecFromTemplate)
5444 dyn_cast<VarTemplateSpecializationDecl>(OldVar)) {
5446 !isa<VarTemplatePartialSpecializationDecl>(OldVTSD))
5447 cast<VarTemplateSpecializationDecl>(NewVar)->setSpecializationKind(
5456 if (InstantiatingVarTemplate || InstantiatingVarTemplatePartialSpec) {
5461 }
else if (InstantiatingSpecFromTemplate ||
5484 L->VariableDefinitionInstantiated(Var);
5508 if (!
Init.isInvalid()) {
5511 if (Var->
hasAttr<DLLImportAttr>() &&
5515 }
else if (InitExpr) {
5566 bool DefinitionRequired,
bool AtEndOfTU) {
5578 assert(PatternDecl &&
"no pattern for templated variable");
5583 dyn_cast<VarTemplateSpecializationDecl>(Var);
5594 (PatternDecl = PatternDecl->
getFirstDecl())->hasInit() &&
5602 "instantiating variable initializer");
5620 PreviousContext.
pop();
5624 LocalInstantiations.
perform();
5626 GlobalInstantiations.
perform();
5630 "not a static data member?");
5639 if (!Def && !DefinitionRequired) {
5642 std::make_pair(Var, PointOfInstantiation));
5647 Diag(PointOfInstantiation, diag::warn_var_template_missing)
5651 Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
5662 PatternDecl, Def, TSK,
5663 DefinitionRequired))
5680 struct PassToConsumerRAII {
5685 : Consumer(Consumer), Var(Var) { }
5687 ~PassToConsumerRAII() {
5690 } PassToConsumerRAII(
Consumer, Var);
5697 PointOfInstantiation);
5705 "instantiating variable definition");
5725 }
else if (!VarSpec) {
5754 cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
5765 PreviousContext.
pop();
5768 PassToConsumerRAII.Var = Var;
5775 LocalInstantiations.
perform();
5777 GlobalInstantiations.
perform();
5789 for (
const auto *
Init : Tmpl->
inits()) {
5792 if (!
Init->isWritten())
5797 if (
Init->isPackExpansion()) {
5799 TypeLoc BaseTL =
Init->getTypeSourceInfo()->getTypeLoc();
5803 bool ShouldExpand =
false;
5804 bool RetainExpansion =
false;
5805 std::optional<unsigned> NumExpansions;
5809 TemplateArgs, ShouldExpand,
5816 assert(ShouldExpand &&
"Partial instantiation of base initializer?");
5819 for (
unsigned I = 0; I != *NumExpansions; ++I) {
5833 Init->getSourceLocation(),
5842 BaseTInfo, TempInit.
get(),
5850 NewInits.push_back(NewInit.
get());
5865 if (
Init->isDelegatingInitializer() ||
Init->isBaseInitializer()) {
5868 Init->getSourceLocation(),
5876 if (
Init->isBaseInitializer())
5882 }
else if (
Init->isMemberInitializer()) {
5884 Init->getMemberLocation(),
5894 Init->getSourceLocation());
5895 }
else if (
Init->isIndirectMemberInitializer()) {
5898 Init->getMemberLocation(),
5899 Init->getIndirectMember(), TemplateArgs));
5901 if (!IndirectMember) {
5908 Init->getSourceLocation());
5915 NewInits.push_back(NewInit.
get());
5934 Instance = Instance->getCanonicalDecl();
5935 if (Pattern == Instance)
return true;
5936 Instance = Instance->getInstantiatedFromMemberTemplate();
5947 Instance = Instance->getCanonicalDecl();
5948 if (Pattern == Instance)
return true;
5949 Instance = Instance->getInstantiatedFromMemberTemplate();
5959 = cast<ClassTemplatePartialSpecializationDecl>(Pattern->
getCanonicalDecl());
5961 Instance = cast<ClassTemplatePartialSpecializationDecl>(
5962 Instance->getCanonicalDecl());
5963 if (Pattern == Instance)
5965 Instance = Instance->getInstantiatedFromMember();
5976 Instance = Instance->getCanonicalDecl();
5977 if (Pattern == Instance)
return true;
5978 Instance = Instance->getInstantiatedFromMemberClass();
5989 Instance = Instance->getCanonicalDecl();
5990 if (Pattern == Instance)
return true;
5991 Instance = Instance->getInstantiatedFromMemberFunction();
6002 Instance = Instance->getCanonicalDecl();
6003 if (Pattern == Instance)
return true;
6004 Instance = Instance->getInstantiatedFromMemberEnum();
6031 bool OtherIsPackExpansion;
6033 if (
auto *OtherUUD = dyn_cast<T>(
Other)) {
6034 OtherIsPackExpansion = OtherUUD->isPackExpansion();
6036 }
else if (
auto *OtherUPD = dyn_cast<UsingPackDecl>(
Other)) {
6037 OtherIsPackExpansion =
true;
6038 OtherFrom = OtherUPD->getInstantiatedFromUsingDecl();
6039 }
else if (
auto *OtherUD = dyn_cast<UsingDecl>(
Other)) {
6040 OtherIsPackExpansion =
false;
6045 return Pattern->isPackExpansion() == OtherIsPackExpansion &&
6051 assert(Instance->isStaticDataMember());
6056 Instance = Instance->getCanonicalDecl();
6057 if (Pattern == Instance)
return true;
6058 Instance = Instance->getInstantiatedFromStaticDataMember();
6067 if (
auto *UUD = dyn_cast<UnresolvedUsingTypenameDecl>(D))
6070 if (
auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(D))
6076 if (
auto *
Record = dyn_cast<CXXRecordDecl>(
Other))
6082 if (
auto *
Enum = dyn_cast<EnumDecl>(
Other))
6085 if (
auto *Var = dyn_cast<VarDecl>(
Other))
6089 if (
auto *Temp = dyn_cast<ClassTemplateDecl>(
Other))
6092 if (
auto *Temp = dyn_cast<FunctionTemplateDecl>(
Other))
6095 if (
auto *PartialSpec =
6096 dyn_cast<ClassTemplatePartialSpecializationDecl>(
Other))
6100 if (
auto *Field = dyn_cast<FieldDecl>(
Other)) {
6101 if (!Field->getDeclName()) {
6104 cast<FieldDecl>(D));
6108 if (
auto *Using = dyn_cast<UsingDecl>(
Other))
6111 if (
auto *Shadow = dyn_cast<UsingShadowDecl>(
Other))
6118template<
typename ForwardIterator>
6121 ForwardIterator first,
6122 ForwardIterator last) {
6123 for (; first != last; ++first)
6125 return cast<NamedDecl>(*first);
6136 if (
NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
6138 return cast_or_null<DeclContext>(ID);
6153 return cast<Decl>(DC)->getTemplateDepth() > Level;
6184 bool FindingInstantiatedContext) {
6206 if (isa<ParmVarDecl>(D) && !ParentDependsOnArgs &&
6207 !cast<ParmVarDecl>(D)->getType()->isInstantiationDependentType())
6209 if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
6210 isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
6212 isa<OMPDeclareReductionDecl>(ParentDC) ||
6213 isa<OMPDeclareMapperDecl>(ParentDC))) ||
6214 (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda() &&
6215 cast<CXXRecordDecl>(D)->getTemplateDepth() >
6221 if (
Decl *FD = Found->dyn_cast<
Decl *>())
6222 return cast<NamedDecl>(FD);
6225 assert(PackIdx != -1 &&
6226 "found declaration pack but not pack expanding");
6228 return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
6235 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
6236 isa<TemplateTemplateParmDecl>(D))
6255 bool NeedInstantiate =
false;
6257 NeedInstantiate = RD->isLocalClass();
6258 else if (isa<TypedefNameDecl>(D) &&
6260 NeedInstantiate =
true;
6262 NeedInstantiate = isa<EnumDecl>(D);
6263 if (NeedInstantiate) {
6266 return cast<TypeDecl>(Inst);
6271 assert(isa<LabelDecl>(D));
6274 assert(Inst &&
"Failed to instantiate label??");
6277 return cast<LabelDecl>(Inst);
6281 if (!
Record->isDependentContext())
6290 dyn_cast<ClassTemplateSpecializationDecl>(
Record))
6291 ClassTemplate = Spec->getSpecializedTemplate()->getCanonicalDecl();
6302 if (
CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
6306 = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
6326 auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FD);
6327 if (Guide && Guide->isImplicit()) {
6335 Unpacked = Arg.pack_elements();
6360 if (FindingInstantiatedContext &&
6362 Loc, cast<ClassTemplateSpecializationDecl>(SubstRecord))) {
6363 Diag(Loc, diag::err_specialization_not_primary_template)
6380 if (!ParentDependsOnArgs)
6394 bool IsBeingInstantiated =
false;
6395 if (
CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
6396 if (!Spec->isDependentContext()) {
6399 assert(Tag &&
"type of non-dependent record is not a RecordType");
6401 IsBeingInstantiated =
true;
6438 if (isa<UsingShadowDecl>(D)) {
6445 }
else if (IsBeingInstantiated) {
6451 Diag(Loc, diag::err_member_not_yet_instantiated)
6459 EnumDecl *
Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
6464 Diag(Loc, diag::err_enumerator_does_not_exist)
6471 llvm_unreachable(
"Unable to find instantiation of declaration!");
6484 std::deque<PendingImplicitInstantiation> delayedPCHInstantiations;
6499 bool DefinitionRequired =
Function->getTemplateSpecializationKind() ==
6505 DefinitionRequired,
true);
6511 DefinitionRequired,
true);
6513 Function->setInstantiationIsPending(
false);
6516 if (!LocalOnly &&
LangOpts.PCHInstantiateTemplates &&
6518 delayedPCHInstantiations.push_back(Inst);
6523 VarDecl *Var = cast<VarDecl>(Inst.first);
6526 isa<VarTemplateSpecializationDecl>(Var)) &&
6527 "Not a static data member, nor a variable template"
6528 " specialization?");
6540 llvm_unreachable(
"Cannot instantitiate an undeclared specialization.");
6555 "instantiating variable definition");
6562 DefinitionRequired,
true);
6565 if (!LocalOnly &&
LangOpts.PCHInstantiateTemplates)
6571 for (
auto *DD : Pattern->
ddiags()) {
6572 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 for CUDA constructs.
This file declares semantic analysis for OpenMP constructs and clauses.
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,...
TypeSourceInfo * getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &Args, QualType Canon=QualType()) const
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)
SourceLocation getColonLoc() const
The location of the colon following the access specifier.
SourceLocation getAccessSpecifierLoc() const
The location of the access specifier.
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.
shadow_range shadows() const
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.
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
unsigned getLambdaDependencyKind() const
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
bool isLambda() const
Determine whether this class describes a lambda function object.
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...
TypeSourceInfo * getLambdaTypeInfo() const
void setInstantiationOfMemberClass(CXXRecordDecl *RD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member class RD.
LambdaCaptureDefault getLambdaCaptureDefault() const
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.
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations() const
Retrieve the set of partial specializations of this class 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)
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, const TemplateArgumentListInfo &ArgInfos, 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.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
TypeSourceInfo * getTypeAsWritten() const
Gets the type of this specialization as it was written by the user, if it was so written.
void setSpecializationKind(TemplateSpecializationKind TSK)
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
void setExternLoc(SourceLocation Loc)
Sets the location of the extern keyword.
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).
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)
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.
TemplateParameterList * getTemplateParameterList(unsigned index) const
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getNumTemplateParameterLists() const
void setTypeSourceInfo(TypeSourceInfo *TI)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
TypeSourceInfo * getTypeSourceInfo() const
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Represents the type decltype(expr) (C++11).
Expr * getUnderlyingExpr() const
A decomposition declaration.
ArrayRef< BindingDecl * > bindings() const
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.
bool isScopedUsingClassTag() 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,...
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
EnumDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
EnumDecl * getDefinition() const
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.
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.
bool isMutable() const
Determines whether this field is mutable (C++ only).
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
Expr * getBitWidth() const
Returns the expression that represents the bit width, if this field is a bit field.
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)
bool isUnsupportedFriend() const
Determines if this friend kind is unsupported.
SourceLocation getFriendLoc() const
Retrieves the location of the 'friend' keyword.
void setUnsupportedFriend(bool Unsupported)
NamedDecl * getFriendDecl() const
If this friend declaration doesn't name a type, return the inner declaration.
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
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.
ConstexprSpecKind getConstexprKind() const
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)
StringLiteral * getDeletedMessage() const
Get the message that indicates why this function was deleted.
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
bool UsesFPIntrin() const
Determine whether the function was declared in source context that requires constrained FP intrinsics...
void setInstantiationOfMemberFunction(FunctionDecl *FD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member function FD.
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
bool hasWrittenPrototype() const
Whether this function has a written prototype.
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
bool isDeleted() const
Whether this function has been deleted.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function.
bool FriendConstraintRefersToEnclosingTemplate() const
bool isDeletedAsWritten() const
void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template, const TemplateArgumentList *TemplateArgs, void *InsertPos, TemplateSpecializationKind TSK=TSK_ImplicitInstantiation, const TemplateArgumentListInfo *TemplateArgsAsWritten=nullptr, SourceLocation PointOfInstantiation=SourceLocation())
Specify that this function declaration is actually a function template specialization.
bool isPureVirtual() const
Whether this virtual function is pure, i.e.
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)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
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.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
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.
const ASTTemplateArgumentListInfo * getTemplateSpecializationArgsAsWritten() const
Retrieve the template argument list as written in the sources, if any.
Represents a prototype with parameter type info, e.g.
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)
unsigned getChainingSize() const
ArrayRef< NamedDecl * > chain() const
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)
IdentifierInfo * getGetterId() const
IdentifierInfo * getSetterId() const
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.
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Represents a C++ namespace alias.
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
SourceLocation getAliasLoc() const
Returns the location of the alias name, i.e.
SourceLocation getNamespaceLoc() const
Returns the location of the namespace keyword.
SourceLocation getTargetNameLoc() const
Returns the location of the identifier in the named namespace.
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
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 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.
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
TypeSourceInfo * getExpansionTypeSourceInfo(unsigned I) const
Retrieve a particular expansion type source info within an expanded parameter pack.
unsigned getNumExpansionTypes() const
Retrieves the number of expansion types in an expanded parameter pack.
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
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)
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
void setDefaultArgument(Expr *DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
unsigned getDepth() const
Get the nesting depth of the template parameter.
Expr * getPlaceholderTypeConstraint() const
Return the constraint introduced by the placeholder type of this non-type template parameter (if any)...
This represents '#pragma omp allocate ...' directive.
clauselist_range clauselists()
Pseudo declaration for capturing expressions.
This is a basic class for representing single OpenMP clause.
This represents '#pragma omp declare mapper ...' directive.
OMPDeclareMapperDecl * getPrevDeclInScope()
Get reference to previous declare mapper construct in the same scope with the same name.
clauselist_iterator clauselist_begin()
clauselist_range clauselists()
DeclarationName getVarName()
Get the name of the variable declared in the mapper.
Expr * getMapperVarRef()
Get the variable declared in the mapper.
This represents '#pragma omp declare reduction ...' directive.
Expr * getInitializer()
Get initializer expression (if specified) of the declare reduction construct.
Expr * getInitPriv()
Get Priv variable of the initializer.
Expr * getCombinerOut()
Get Out variable of the combiner.
Expr * getCombinerIn()
Get In variable of the combiner.
Expr * getCombiner()
Get combiner expression of the declare reduction construct.
OMPDeclareReductionDecl * getPrevDeclInScope()
Get reference to previous declare reduction construct in the same scope with the same name.
Expr * getInitOrig()
Get Orig variable of the initializer.
OMPDeclareReductionInitKind getInitializerKind() const
Get initializer kind.
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.
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
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...
RecordDecl * getDecl() const
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.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
void checkAllowedInitializer(VarDecl *VD)
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'.
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.
bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New)
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.
void addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI, Expr *Min, Expr *Max)
addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu 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.
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...
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.
void AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI, RetainOwnershipKind K, bool IsTemplateInstantiation)
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 ...
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.
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
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.
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)
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, bool UpdateArgsWithConversions=true, bool *ConstraintsNotSatisfied=nullptr)
Check that the given template arguments can be provided to the given template, converting the argumen...
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.
bool inferObjCARCLifetime(ValueDecl *decl)
@ 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.
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)
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 AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI, ParameterABI ABI)
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.
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.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
Represents a C++11 static_assert declaration.
SourceLocation getRParenLoc() const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
Represents the declaration of a struct/union/class/enum.
bool isThisDeclarationADefinition() const
Return true if this declaration is a completion definition of the type.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
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 isBeingDefined() const
Determines whether this type is in the process of being defined.
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.
const TemplateArgument & getArgument() const
SourceLocation getTemplateNameLoc() const
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Represents a template argument.
TemplateName getAsTemplate() const
Retrieve the template name for a template name 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 * 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
unsigned getNumArgs() const
SourceLocation getLAngleLoc() const
TemplateArgumentLoc getArgLoc(unsigned i) const
SourceLocation getRAngleLoc() const
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
bool wasDeclaredWithTypename() const
Whether this template template parameter was declared with the 'typename' keyword.
TemplateParameterList * getExpansionTemplateParameters(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
unsigned getNumExpansionTemplateParameters() const
Retrieves the number of expansion template parameters in an expanded parameter pack.
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
unsigned getDepth() const
Get the nesting depth of the template parameter.
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, bool Typename, TemplateParameterList *Params)
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Declaration of a template type parameter.
bool wasDeclaredWithTypename() const
Whether this template type parameter was declared with the 'typename' keyword.
SourceLocation getDefaultArgumentLoc() const
Retrieves the location of the default argument declaration.
unsigned getIndex() const
Retrieve the index of the template parameter.
bool hasTypeConstraint() const
Determine whether this template parameter has a type-constraint.
TypeSourceInfo * getDefaultArgumentInfo() const
Retrieves the default argument's source information, if any.
const TypeConstraint * getTypeConstraint() const
Returns the type constraint associated with this template parameter (if any).
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)
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
bool isExpandedParameterPack() const
Whether this parameter is a template type parameter pack that has a known list of different type-cons...
void setDefaultArgument(TypeSourceInfo *DefArg)
Set the default argument for this template parameter.
bool isParameterPack() const
Returns whether this is a parameter pack.
unsigned getDepth() const
Retrieve the depth of the template parameter.
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
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.
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
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 containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
bool isTemplateTypeParmType() const
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.
TypeSourceInfo * getTypeSourceInfo() const
QualType getUnderlyingType() const
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.
bool hasTypename() const
Return true if the using declaration has 'typename'.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
DeclarationNameInfo getNameInfo() const
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
SourceLocation getUsingLoc() const
Return the source location of the 'using' keyword.
Represents C++ using-directive.
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
DeclContext * getCommonAncestor()
Returns the common ancestor context of this using-directive and its nominated namespace.
SourceLocation getNamespaceKeyLocation() const
Returns the location of the namespace keyword.
SourceLocation getIdentLocation() const
Returns the location of this using declaration's identifier.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Represents a C++ using-enum-declaration.
SourceLocation getEnumLoc() const
The source location of the 'enum' keyword.
EnumDecl * getEnumDecl() const
TypeSourceInfo * getEnumType() const
static UsingEnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, SourceLocation EnumL, SourceLocation NameL, TypeSourceInfo *EnumType)
SourceLocation getUsingLoc() const
The source location of the 'using' keyword.
Represents a pack of using declarations that a single using-declarator pack-expanded into.
ArrayRef< NamedDecl * > expansions() const
Get the set of using declarations that this 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...
bool isNRVOVariable() const
Determine whether this local variable can be used with the named return value optimization (NRVO).
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.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the 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.
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > & getPartialSpecializations() const
Retrieve the set of partial specializations of this class template.
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 ...
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
static VarTemplatePartialSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args, const TemplateArgumentListInfo &ArgInfos)
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 setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo)
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...
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
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.
const ASTTemplateArgumentListInfo * getTemplateArgsInfo() const
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.
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...