27 using namespace clang;
54 bool RelativeToPrimary,
68 dyn_cast<VarTemplateSpecializationDecl>(D)) {
71 !isa<VarTemplatePartialSpecializationDecl>(Spec))
78 assert(Spec->getSpecializedTemplate() &&
"No variable template?");
84 if (Partial->isMemberSpecialization())
87 VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
101 = dyn_cast<TemplateTemplateParmDecl>(D)) {
102 for (
unsigned I = 0, N = TTP->getDepth() + 1;
I != N; ++
I)
112 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
115 !isa<ClassTemplatePartialSpecializationDecl>(Spec))
122 assert(Spec->getSpecializedTemplate() &&
"No class template?");
123 if (Spec->getSpecializedTemplate()->isMemberSpecialization())
127 else if (
FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
128 if (!RelativeToPrimary &&
129 (Function->getTemplateSpecializationKind() ==
131 !Function->getClassScopeSpecializationPattern()))
135 = Function->getTemplateSpecializationArgs()) {
141 assert(Function->getPrimaryTemplate() &&
"No function template?");
142 if (Function->getPrimaryTemplate()->isMemberSpecialization())
150 = Function->getDescribedFunctionTemplate()) {
159 if (Function->getFriendObjectKind() &&
160 Function->getDeclContext()->isFileContext() &&
162 Ctx = Function->getLexicalDeclContext();
163 RelativeToPrimary =
false;
166 }
else if (
CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
168 QualType T = ClassTemplate->getInjectedClassNameSpecialization();
172 llvm::makeArrayRef(TST->getArgs(), TST->getNumArgs()));
173 if (ClassTemplate->isMemberSpecialization())
179 RelativeToPrimary =
false;
187 case TemplateInstantiation:
188 case ExceptionSpecInstantiation:
189 case DefaultTemplateArgumentInstantiation:
190 case DefaultFunctionArgumentInstantiation:
191 case ExplicitTemplateArgumentSubstitution:
192 case DeducedTemplateArgumentSubstitution:
193 case PriorTemplateArgumentSubstitution:
196 case DefaultTemplateArgumentChecking:
200 llvm_unreachable(
"Invalid InstantiationKind!");
208 : SemaRef(SemaRef), SavedInNonInstantiationSFINAEContext(
209 SemaRef.InNonInstantiationSFINAEContext) {
216 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
223 Inst.TemplateArgs = TemplateArgs.data();
224 Inst.NumTemplateArgs = TemplateArgs.size();
229 if (!Inst.isInstantiationRecord())
239 PointOfInstantiation, InstantiationRange, Entity) {}
246 PointOfInstantiation, InstantiationRange, Entity) {}
254 PointOfInstantiation, InstantiationRange, Template, nullptr,
264 InstantiationRange, FunctionTemplate, nullptr,
265 TemplateArgs, &DeductionInfo) {}
275 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
276 TemplateArgs, &DeductionInfo) {}
286 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
287 TemplateArgs, &DeductionInfo) {}
295 PointOfInstantiation, InstantiationRange, Param, nullptr,
305 PointOfInstantiation, InstantiationRange, Param, Template,
315 PointOfInstantiation, InstantiationRange, Param, Template,
324 PointOfInstantiation, InstantiationRange, Param, Template,
334 = SavedInNonInstantiationSFINAEContext;
339 "forgot to remove a lookup module for a template instantiation");
352 bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
362 SemaRef.
Diag(PointOfInstantiation,
363 diag::err_template_recursion_depth_exceeded)
365 << InstantiationRange;
366 SemaRef.
Diag(PointOfInstantiation, diag::note_template_recursion_depth)
378 SkipStart = Limit / 2 + Limit % 2;
383 unsigned InstantiationIdx = 0;
388 ++Active, ++InstantiationIdx) {
390 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
391 if (InstantiationIdx == SkipStart) {
394 diag::note_instantiation_contexts_suppressed)
400 switch (Active->Kind) {
402 Decl *D = Active->Entity;
404 unsigned DiagID = diag::note_template_member_class_here;
405 if (isa<ClassTemplateSpecializationDecl>(Record))
406 DiagID = diag::note_template_class_instantiation_here;
409 << Active->InstantiationRange;
410 }
else if (
FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
412 if (Function->getPrimaryTemplate())
413 DiagID = diag::note_function_template_spec_here;
415 DiagID = diag::note_template_member_function_here;
418 << Active->InstantiationRange;
419 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
421 VD->isStaticDataMember()?
422 diag::note_template_static_data_member_def_here
423 : diag::note_template_variable_def_here)
425 << Active->InstantiationRange;
426 }
else if (
EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
428 diag::note_template_enum_def_here)
430 << Active->InstantiationRange;
431 }
else if (
FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
433 diag::note_template_nsdmi_here)
434 << FD << Active->InstantiationRange;
437 diag::note_template_type_alias_instantiation_here)
438 << cast<TypeAliasTemplateDecl>(D)
439 << Active->InstantiationRange;
445 TemplateDecl *Template = cast<TemplateDecl>(Active->Entity);
447 llvm::raw_svector_ostream OS(TemplateArgsStr);
450 Active->TemplateArgs,
451 Active->NumTemplateArgs,
454 diag::note_default_arg_instantiation_here)
456 << Active->InstantiationRange;
463 diag::note_explicit_template_arg_substitution_here)
466 Active->TemplateArgs,
467 Active->NumTemplateArgs)
468 << Active->InstantiationRange;
474 dyn_cast<ClassTemplatePartialSpecializationDecl>(Active->Entity)) {
476 diag::note_partial_spec_deduct_instantiation_here)
479 PartialSpec->getTemplateParameters(),
480 Active->TemplateArgs,
481 Active->NumTemplateArgs)
482 << Active->InstantiationRange;
485 = cast<FunctionTemplateDecl>(Active->Entity);
487 diag::note_function_template_deduction_instantiation_here)
490 Active->TemplateArgs,
491 Active->NumTemplateArgs)
492 << Active->InstantiationRange;
497 ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
501 llvm::raw_svector_ostream OS(TemplateArgsStr);
504 Active->TemplateArgs,
505 Active->NumTemplateArgs,
508 diag::note_default_function_arg_instantiation_here)
510 << Active->InstantiationRange;
515 NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
518 Name = std::string(
" '") + Parm->
getName().str() +
"'";
521 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
522 TemplateParams = Template->getTemplateParameters();
525 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
526 ->getTemplateParameters();
528 diag::note_prior_template_arg_substitution)
529 << isa<TemplateTemplateParmDecl>(Parm)
532 Active->TemplateArgs,
533 Active->NumTemplateArgs)
534 << Active->InstantiationRange;
540 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
541 TemplateParams = Template->getTemplateParameters();
544 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
545 ->getTemplateParameters();
548 diag::note_template_default_arg_checking)
550 Active->TemplateArgs,
551 Active->NumTemplateArgs)
552 << Active->InstantiationRange;
558 diag::note_template_exception_spec_instantiation_here)
559 << cast<FunctionDecl>(Active->Entity)
560 << Active->InstantiationRange;
576 switch(Active->Kind) {
580 if (isa<TypeAliasTemplateDecl>(Active->Entity))
600 assert(Active->DeductionInfo &&
"Missing deduction info pointer");
601 return Active->DeductionInfo;
609 static std::pair<unsigned, unsigned>
612 return std::make_pair(TTP->getDepth(), TTP->getIndex());
615 return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
625 class TemplateInstantiator :
public TreeTransform<TemplateInstantiator> {
633 TemplateInstantiator(
Sema &SemaRef,
637 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
645 bool AlreadyTransformed(
QualType T);
657 this->Entity = Entity;
663 bool &ShouldExpand,
bool &RetainExpansion,
665 return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
666 PatternRange, Unexpanded,
673 void ExpandingFunctionParameterPack(
ParmVarDecl *Pack) {
683 unsigned Depth, Index;
686 Result = TemplateArgs(Depth, Index);
702 unsigned Depth, Index;
712 void transformAttrs(
Decl *Old,
Decl *New) {
716 void transformedLocalDecl(
Decl *Old,
Decl *New) {
723 if (
auto *NewTD = NewMD->getDescribedFunctionTemplate())
724 NewTD->setInstantiatedFromMemberTemplate(
725 OldMD->getDescribedFunctionTemplate());
766 NamedDecl *FirstQualifierInScope =
nullptr);
768 const LoopHintAttr *TransformLoopHintAttr(
const LoopHintAttr *LH);
776 ExprResult TransformSubstNonTypeTemplateParmPackExpr(
794 return inherited::TransformFunctionProtoType(TLB, TL);
797 template<
typename Fn>
801 unsigned ThisTypeQuals,
802 Fn TransformExceptionSpec);
807 bool ExpectParameterPack);
827 if (!OrigTPL || !OrigTPL->
size())
return OrigTPL;
831 Owner, TemplateArgs);
832 return DeclInstantiator.SubstTemplateParams(OrigTPL);
841 bool TemplateInstantiator::AlreadyTransformed(
QualType T) {
848 getSema().MarkDeclarationsReferencedInType(Loc, T);
857 if (Arg.isPackExpansion())
878 if (TTP->isParameterPack()) {
880 "Missing argument pack");
886 "Wrong kind of template template argument");
898 Decl *Inst = getSema().SubstDecl(D, getSema().
CurContext, TemplateArgs);
902 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
907 TemplateInstantiator::TransformFirstQualifierInScope(
NamedDecl *D,
913 = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));
921 "Missing argument pack");
923 if (getSema().ArgumentPackSubstitutionIndex == -1)
931 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
934 return Tag->getDecl();
937 getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
942 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
946 TemplateInstantiator::RebuildExceptionDecl(
VarDecl *ExceptionDecl,
951 VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
952 StartLoc, NameLoc, Name);
954 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
958 VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(
VarDecl *ExceptionDecl,
961 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
963 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
968 TemplateInstantiator::RebuildElaboratedType(
SourceLocation KeywordLoc,
985 SemaRef.
Diag(TagLocation, diag::err_use_with_wrong_tag)
1013 TTP->getPosition()))
1020 "Missing argument pack");
1022 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1026 return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
1033 assert(!Template.
isNull() &&
"Null template template argument");
1041 Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
1048 if (getSema().ArgumentPackSubstitutionIndex == -1)
1056 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
1057 FirstQualifierInScope);
1069 TemplateInstantiator::TransformTemplateParmRefExpr(
DeclRefExpr *E,
1082 "Missing argument pack");
1084 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1103 return transformNonTypeTemplateParmRef(NTTP, E->
getLocation(), Arg);
1106 const LoopHintAttr *
1107 TemplateInstantiator::TransformLoopHintAttr(
const LoopHintAttr *LH) {
1108 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).
get();
1110 if (TransformedExpr == LH->getValue())
1114 if (getSema().CheckLoopHintExpr(TransformedExpr, LH->getLocation()))
1119 return LoopHintAttr::CreateImplicit(
1120 getSema().
Context, LH->getSemanticSpelling(), LH->getOption(),
1121 LH->getState(), TransformedExpr, LH->getRange());
1124 ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
1146 VD = cast_or_null<ValueDecl>(
1147 getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
1160 isa<PackExpansionType>(parm->
getType())) {
1162 cast<PackExpansionType>(parm->
getType())->getPattern(),
1168 assert(!type.
isNull() &&
"type substitution failed for param type");
1172 if (!result.isInvalid()) type = result.get()->getType();
1180 if (result.isInvalid())
return ExprError();
1182 Expr *resultExpr = result.get();
1184 type, resultExpr->
getValueKind(), loc, parm, resultExpr);
1188 TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
1203 TemplateInstantiator::RebuildParmVarDeclRefExpr(
ParmVarDecl *PD,
1206 return getSema().BuildDeclarationNameExpr(
CXXScopeSpec(), NameInfo, PD);
1217 return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(VD), E->
getExprLoc());
1231 cast_or_null<ParmVarDecl>(TransformDecl(E->
getExprLoc(), *
I));
1243 TemplateInstantiator::TransformFunctionParmPackRefExpr(
DeclRefExpr *E,
1246 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
1247 = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
1248 assert(Found &&
"no instantiation for parameter pack");
1250 Decl *TransformedDecl;
1251 if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
1262 TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
1264 TransformedDecl = Found->get<
Decl*>();
1268 return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(TransformedDecl),
1273 TemplateInstantiator::TransformDeclRefExpr(
DeclRefExpr *E) {
1280 return TransformTemplateParmRefExpr(E, NTTP);
1289 return TransformFunctionParmPackRefExpr(E, PD);
1294 ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
1297 getDescribedFunctionTemplate() &&
1298 "Default arg expressions are never formed in dependent cases.");
1304 template<
typename Fn>
1308 unsigned ThisTypeQuals,
1309 Fn TransformExceptionSpec) {
1312 return inherited::TransformFunctionProtoType(
1313 TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
1317 TemplateInstantiator::TransformFunctionTypeParam(
ParmVarDecl *OldParm,
1318 int indexAdjustment,
1320 bool ExpectParameterPack) {
1322 NumExpansions, ExpectParameterPack);
1326 TemplateInstantiator::TransformTemplateTypeParmType(
TypeLocBuilder &TLB,
1348 "Missing argument pack");
1350 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1355 = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
1366 "Template argument kind mismatch");
1372 = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
1385 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
1389 = getSema().Context.getTemplateTypeParmType(T->
getDepth()
1400 TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
1415 Result = getSema().Context.getSubstTemplateTypeParmType(
1456 "Cannot perform an instantiation without some context on the "
1457 "instantiation stack");
1463 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1464 return Instantiator.TransformType(T);
1472 "Cannot perform an instantiation without some context on the "
1473 "instantiation stack");
1487 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1490 QualType Result = Instantiator.TransformType(TLB, TL);
1502 "Cannot perform an instantiation without some context on the "
1503 "instantiation stack");
1510 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc, Entity);
1511 return Instantiator.TransformType(T);
1555 unsigned ThisTypeQuals) {
1557 "Cannot perform an instantiation without some context on the "
1558 "instantiation stack");
1563 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1579 Result = Instantiator.TransformFunctionProtoType(
1580 TLB, Proto, ThisContext, ThisTypeQuals,
1582 bool &Changed) {
return false; });
1584 Result = Instantiator.TransformType(TLB, TL);
1598 TemplateInstantiator Instantiator(*
this, Args, New->
getLocation(),
1602 bool Changed =
false;
1603 if (Instantiator.TransformExceptionSpec(
1605 ExceptionStorage, Changed))
1614 int indexAdjustment,
1616 bool ExpectParameterPack) {
1625 NewDI =
SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
1636 }
else if (ExpectParameterPack) {
1642 diag::err_function_parameter_pack_without_parameter_packs)
1727 "Cannot perform an instantiation without some context on the "
1728 "instantiation stack");
1730 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
1732 return Instantiator.TransformFunctionTypeParams(Loc, Params, NumParams,
1733 nullptr, ParamTypes,
1747 bool Invalid =
false;
1749 for (
const auto &
Base : Pattern->
bases()) {
1750 if (!
Base.getType()->isDependentType()) {
1752 if (RD->isInvalidDecl())
1761 if (
Base.isPackExpansion()) {
1767 bool ShouldExpand =
false;
1768 bool RetainExpansion =
false;
1771 Base.getSourceRange(),
1773 TemplateArgs, ShouldExpand,
1782 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
1787 Base.getSourceRange().getBegin(),
1796 Base.getSourceRange(),
1798 Base.getAccessSpecifierAsWritten(),
1801 InstantiatedBases.push_back(InstantiatedBase);
1810 EllipsisLoc =
Base.getEllipsisLoc();
1814 Base.getSourceRange().getBegin(),
1819 Base.getSourceRange().getBegin(),
1830 Base.getSourceRange(),
1832 Base.getAccessSpecifierAsWritten(),
1835 InstantiatedBases.push_back(InstantiatedBase);
1859 bool InstantiatedFromMember,
1863 bool Complain =
true) {
1867 if (!Complain || (PatternDef && PatternDef->
isInvalidDecl())) {
1869 }
else if (PatternDef) {
1871 S.
Diag(PointOfInstantiation,
1872 diag::err_template_instantiate_within_definition)
1878 }
else if (InstantiatedFromMember) {
1879 S.
Diag(PointOfInstantiation,
1880 diag::err_implicit_instantiate_member_undefined)
1884 S.
Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
1931 Pattern, PatternDef, TSK, Complain))
1933 Pattern = PatternDef;
1939 MSInfo->setPointOfInstantiation(PointOfInstantiation);
1941 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
1942 Spec->setTemplateSpecializationKind(TSK);
1943 Spec->setPointOfInstantiation(PointOfInstantiation);
1985 for (
auto *Member : Pattern->
decls()) {
1995 if (Member->getDeclContext() != Pattern)
1998 if (Member->isInvalidDecl()) {
2003 Decl *NewMember = Instantiator.
Visit(Member);
2005 if (
FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
2006 Fields.push_back(Field);
2007 }
else if (
EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
2013 Enum->isCompleteDefinition()) {
2015 assert(MSInfo &&
"no spec info for member enum specialization");
2020 if (SA->isFailed()) {
2050 E = LateAttrs.end();
I !=
E; ++
I) {
2063 I->NewDecl->addAttr(NewAttr);
2091 P->first,
P->second)) {
2104 P->first,
P->second)) {
2148 Pattern, PatternDef, TSK,
true))
2150 Pattern = PatternDef;
2156 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2211 "pattern and instantiation disagree about init style");
2219 if (OutermostClass == PatternRD) {
2220 Diag(Pattern->
getLocEnd(), diag::err_in_class_initializer_not_yet_parsed)
2221 << PatternRD << Pattern;
2224 diag::err_in_class_initializer_not_yet_parsed_outer_class)
2225 << PatternRD << OutermostClass << Pattern;
2249 Expr *Init = NewInit.get();
2250 assert((!Init || !isa<ParenListExpr>(Init)) &&
"call-style init in class");
2252 Instantiation, Init ? Init->getLocStart() :
SourceLocation(), Init);
2264 struct PartialSpecMatchResult {
2275 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
2291 typedef PartialSpecMatchResult MatchResult;
2296 for (
unsigned I = 0, N = PartialSpecs.size();
I != N; ++
I) {
2309 Matched.push_back(PartialSpecMatchResult());
2310 Matched.back().Partial = Partial;
2311 Matched.back().Args = Info.take();
2319 if (Matched.size() >= 1) {
2321 if (Matched.size() == 1) {
2334 PEnd = Matched.end();
2337 PointOfInstantiation)
2344 bool Ambiguous =
false;
2346 PEnd = Matched.end();
2350 PointOfInstantiation)
2360 Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
2361 << ClassTemplateSpec;
2365 PEnd = Matched.end();
2367 Diag(
P->Partial->getLocation(), diag::note_partial_spec_match)
2369 P->Partial->getTemplateParameters(),
2387 Pattern = OrigPartialSpec;
2429 "Unexpected template specialization kind!");
2430 for (
auto *D : Instantiation->
decls()) {
2431 bool SuppressNew =
false;
2432 if (
auto *Function = dyn_cast<FunctionDecl>(D)) {
2436 = Function->getMemberSpecializationInfo();
2437 assert(MSInfo &&
"No member specialization information?");
2459 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2461 if (Function->isDefined()) {
2469 std::make_pair(Function, PointOfInstantiation));
2472 }
else if (
auto *Var = dyn_cast<VarDecl>(D)) {
2473 if (isa<VarTemplateSpecializationDecl>(Var))
2478 assert(MSInfo &&
"No member specialization information?");
2508 }
else if (
auto *Record = dyn_cast<CXXRecordDecl>(D)) {
2514 if (Record->isInjectedClassName() || Record->getPreviousDecl() ||
2519 assert(MSInfo &&
"No member specialization information?");
2534 assert(Pattern &&
"Missing instantiated-from-template information");
2536 if (!Record->getDefinition()) {
2557 Record->getTemplateSpecializationKind() ==
2559 Record->setTemplateSpecializationKind(TSK);
2564 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
2568 }
else if (
auto *Enum = dyn_cast<EnumDecl>(D)) {
2570 assert(MSInfo &&
"No member specialization information?");
2577 PointOfInstantiation, TSK, Enum,
2583 if (Enum->getDefinition())
2587 assert(Pattern &&
"Missing instantiated-from-template information");
2593 InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
2598 }
else if (
auto *Field = dyn_cast<FieldDecl>(D)) {
2605 ClassPattern->
lookup(Field->getDeclName());
2606 assert(Lookup.
size() == 1);
2607 FieldDecl *Pattern = cast<FieldDecl>(Lookup[0]);
2641 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2644 return Instantiator.TransformStmt(S);
2652 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2655 return Instantiator.TransformExpr(E);
2660 bool CXXDirectInit) {
2661 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2664 return Instantiator.TransformInitializer(Init, CXXDirectInit);
2673 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2676 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
2686 TemplateInstantiator Instantiator(*
this, TemplateArgs, NNS.
getBeginLoc(),
2688 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
2695 TemplateInstantiator Instantiator(*
this, TemplateArgs, NameInfo.
getLoc(),
2697 return Instantiator.TransformDeclarationNameInfo(NameInfo);
2704 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
2707 SS.
Adopt(QualifierLoc);
2708 return Instantiator.TransformTemplateName(SS, Name, Loc);
2714 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
2717 return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
2725 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
2726 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
2727 unsigned i = PV->getFunctionScopeIndex();
2730 if (FD->getParamDecl(i) == PV)
2738 llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
2745 const Decl *CheckD = D;
2748 if (Found !=
Current->LocalDecls.end())
2749 return &Found->second;
2753 if (
const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
2760 if (!
Current->CombineWithOuterScope)
2766 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
2767 isa<TemplateTemplateParmDecl>(D))
2772 if (RD->isLocalClass())
2777 if (isa<EnumDecl>(D))
2783 assert(isa<LabelDecl>(D) &&
"declaration not instantiated in this scope");
2789 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2790 if (Stored.isNull()) {
2794 while (Current->CombineWithOuterScope && Current->Outer) {
2795 Current = Current->Outer;
2796 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
2797 "Instantiated local in inner and outer scopes");
2801 }
else if (DeclArgumentPack *Pack = Stored.dyn_cast<DeclArgumentPack *>()) {
2802 Pack->push_back(cast<ParmVarDecl>(Inst));
2804 assert(Stored.get<
Decl *>() == Inst &&
"Already instantiated this local");
2811 DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
2812 Pack->push_back(Inst);
2820 assert(
Current->LocalDecls.find(D) ==
Current->LocalDecls.end() &&
2821 "Creating local pack after instantiation of local");
2825 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2826 DeclArgumentPack *Pack =
new DeclArgumentPack;
2828 ArgumentPacks.push_back(Pack);
2833 unsigned NumExplicitArgs) {
2834 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
2835 "Already have a partially-substituted pack");
2836 assert((!PartiallySubstitutedPack
2837 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
2838 "Wrong number of arguments in partially-substituted pack");
2839 PartiallySubstitutedPack = Pack;
2840 ArgsInPartiallySubstitutedPack = ExplicitArgs;
2841 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
2846 unsigned *NumExplicitArgs)
const {
2848 *ExplicitArgs =
nullptr;
2849 if (NumExplicitArgs)
2850 *NumExplicitArgs = 0;
2854 if (
Current->PartiallySubstitutedPack) {
2856 *ExplicitArgs =
Current->ArgsInPartiallySubstitutedPack;
2857 if (NumExplicitArgs)
2858 *NumExplicitArgs =
Current->NumArgsInPartiallySubstitutedPack;
2860 return Current->PartiallySubstitutedPack;
2863 if (!
Current->CombineWithOuterScope)
ExprResult BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg, SourceLocation Loc)
Construct a new expression that refers to the given integral template argument with the given source-...
Defines the clang::ASTContext interface.
void ActOnFinishDelayedMemberInitializers(Decl *Record)
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
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 ...
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
ParmVarDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
SmallVector< Module *, 16 > ActiveTemplateInstantiationLookupModules
Extra modules inspected when performing a lookup during a template instantiation. ...
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier * > Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
unsigned getDepth() const
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
delayed_var_partial_spec_iterator delayed_var_partial_spec_begin()
no exception specification
We are instantiating a default argument for a template parameter.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization, retrieves the member specialization information.
A (possibly-)qualified type.
void setHidden(bool Hide)
Set whether this declaration is hidden from name lookup.
TemplateDeductionResult
Describes the result of template argument deduction.
void InstantiatedLocal(const Decl *D, Decl *Inst)
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
A stack-allocated class that identifies which local variable declaration instantiations are present i...
unsigned getTemplateBacktraceLimit() const
Retrieve the maximum number of template instantiation notes to emit along with a given diagnostic...
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
void addOuterTemplateArguments(const TemplateArgumentList *TemplateArgs)
Add a new outermost level to the multi-level template argument list.
const LangOptions & getLangOpts() const
bool hasDefaultArg() const
hasDefaultArg - Determines whether this parameter has a default argument, either parsed or not...
bool isMemberSpecialization()
Determines whether this class template partial specialization template was a specialization of a memb...
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
ExprResult SubstInitializer(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs, bool CXXDirectInit)
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
Provides information about an attempted template argument deduction, whose success or failure was des...
We are substituting prior template arguments into a new template parameter.
We are instantiating a default argument for a function.
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed...
The current expression is potentially evaluated at run time, which means that code may be generated t...
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
The template argument is an expression, and we've not resolved it to one of the other forms yet...
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments...
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
bool hasTemplateArgument(unsigned Depth, unsigned Index) const
Determine whether there is a non-NULL template argument at the given depth and index.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Decl - This represents one declaration (or definition), e.g.
llvm::PointerUnion< Decl *, DeclArgumentPack * > * findInstantiationOf(const Decl *D)
Find the instantiation of the declaration D within the current instantiation scope.
Defines the C++ template declaration subclasses.
void disableLateAttributeInstantiation()
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization...
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
TemplateSpecializationType(TemplateName T, const TemplateArgument *Args, unsigned NumArgs, QualType Canon, QualType Aliased)
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Declaration of a variable template.
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
NamedDecl * getParam(unsigned Idx)
A container of type source information.
unsigned getIndex() const
Expr * getAsExpr() const
Retrieve the template argument as an expression.
static bool DiagnoseUninstantiableTemplate(Sema &S, SourceLocation PointOfInstantiation, TagDecl *Instantiation, bool InstantiatedFromMember, TagDecl *Pattern, TagDecl *PatternDef, TemplateSpecializationKind TSK, bool Complain=true)
Determine whether we would be unable to instantiate this template (because it either has no definitio...
SourceLocation getLocEnd() const LLVM_READONLY
VarTemplatePartialSpecializationDecl * InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a variable template partial specialization.
void SetPartiallySubstitutedPack(NamedDecl *Pack, const TemplateArgument *ExplicitArgs, unsigned NumExplicitArgs)
Note that the given parameter pack has been partially substituted via explicit specification of templ...
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
unsigned NonInstantiationEntries
The number of ActiveTemplateInstantiation entries in ActiveTemplateInstantiations that are not actual...
We are instantiating a template declaration.
Expr * getInClassInitializer() const
getInClassInitializer - Get the C++11 in-class initializer for this member, or null if one has not be...
InClassInitStyle getInClassInitStyle() const
getInClassInitStyle - Get the kind of (C++11) in-class initializer which this field has...
enum clang::Sema::ActiveTemplateInstantiation::InstantiationKind Kind
IdentType getIdentType() const
void ActOnFinishCXXNonNestedClass(Decl *D)
This file provides some common utility functions for processing Lambda related AST Constructs...
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
void InstantiatedLocalPackArg(const Decl *D, ParmVarDecl *Inst)
RAII object that enters a new expression evaluation context.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Information about one declarator, including the parsed type information and the identifier.
DiagnosticsEngine & Diags
TypeSourceInfo * SubstFunctionDeclType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext, unsigned ThisTypeQuals)
A form of SubstType intended specifically for instantiating the type of a FunctionDecl.
Represents a variable template specialization, which refers to a variable template with a given set o...
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
TemplateTypeParmDecl * getDecl() const
SmallVectorImpl< std::pair< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > >::iterator delayed_partial_spec_iterator
Stores a list of template parameters for a TemplateDecl and its derived classes.
const ParmVarDecl * getParam() const
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
ParmVarDecl - Represents a parameter to a function.
SourceLocation PointOfInstantiation
The point of instantiation within the source code.
SourceLocation getLocation() const
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
Base wrapper for a particular "section" of type source info.
RecordDecl - Represents a struct/union/class.
bool hasUninstantiatedDefaultArg() const
void PrintInstantiationStack()
Prints the current instantiation stack through a series of notes.
DeclarationName getName() const
getName - Returns the embedded declaration name.
One of these records is kept for each identifier that is lexed.
Represents a class template specialization, which refers to a class template with a given set of temp...
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
void setUninstantiatedDefaultArg(Expr *arg)
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
A C++ nested-name-specifier augmented with source location information.
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
The results of name lookup within a DeclContext.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
void setArgument(unsigned Depth, unsigned Index, TemplateArgument Arg)
Clear out a specific template argument.
Decl * Entity
The entity that is being instantiated.
void startDefinition()
Starts the definition of this tag declaration.
ParmVarDecl * getParam(unsigned i) const
CXXRecordDecl * getDefinition() const
bool isTranslationUnit() const
TagKind getTagKind() const
bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, Optional< unsigned > &NumExpansions)
Determine whether we could expand a pack expansion with the given set of parameter packs into separat...
DeclarationNameInfo SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, const MultiLevelTemplateArgumentList &TemplateArgs)
Do template substitution on declaration name info.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
delayed_var_partial_spec_iterator delayed_var_partial_spec_end()
We are checking the validity of a default template argument that has been used when naming a template...
Describes a module or submodule.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
TemplateArgument getArgumentPack() const
void setNameLoc(SourceLocation Loc)
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For an enumeration member that was instantiated from a member enumeration of a templated class...
SourceRange InstantiationRange
The source range that covers the construct that cause the instantiation, e.g., the template-id that c...
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
A convenient class for passing around template argument information.
static TemplateArgument getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg)
StmtResult SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs)
We are substituting template argument determined as part of template argument deduction for either a ...
Wrapper for substituted template type parameters.
llvm::DenseSet< Module * > LookupModulesCache
Cache of additional modules that should be used for name lookup within the current template instantia...
ParmVarDecl * getExpansion(unsigned I) const
Get an expansion of the parameter pack by index.
Wrapper for substituted template type parameters.
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this class template specialization is actually an instantiation of the given class template...
We are substituting explicit template arguments provided for a function template. ...
Scope - A scope is a transient data structure that is used while parsing the program.
bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity, SourceRange InstantiationRange=SourceRange())
Note that we are instantiating a class template, function template, variable template, alias template, or a member thereof.
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
SourceLocation getRBraceLoc() const
CXXBaseSpecifier * CheckBaseSpecifier(CXXRecordDecl *Class, SourceRange SpecifierRange, bool Virtual, AccessSpecifier Access, TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)
ActOnBaseSpecifier - Parsed a base specifier.
Represents a C++ nested-name-specifier or a global scope specifier.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
bool isLambdaCallOperator(const CXXMethodDecl *MD)
SourceLocation getLocation() const
static void PrintTemplateArgumentList(raw_ostream &OS, const TemplateArgument *Args, unsigned NumArgs, const PrintingPolicy &Policy, bool SkipBrackets=false)
Print a template argument list, including the '<' and '>' enclosing the template arguments...
detail::InMemoryDirectory::const_iterator I
unsigned getNumParams() const
SourceLocation getUsedLocation() const
Retrieve the location where this default argument was actually used.
A default argument (C++ [dcl.fct.default]).
void setLocStart(SourceLocation L)
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
RAII object used to change the argument pack substitution index within a Sema object.
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
bool SubstBaseSpecifiers(CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Perform substitution on the base class specifiers of the given class template specialization.
void MakeInstantiatedLocalArgPack(const Decl *D)
sema::TemplateDeductionInfo * DeductionInfo
The template deduction info object associated with the substitution or checking of explicit or deduce...
Sema - This implements semantic analysis and AST building for C.
Represents a prototype with parameter type info, e.g.
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
bool InstantiateEnum(SourceLocation PointOfInstantiation, EnumDecl *Instantiation, EnumDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiate the definition of an enum from a given pattern.
bool isParameterPack() const
Determine whether this parameter is actually a function parameter pack.
unsigned getNumExpansions() const
Get the number of parameters in this parameter pack.
bool CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind NewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPtOfInstantiation, bool &SuppressNew)
Diagnose cases where we have an explicit template specialization before/after an explicit template in...
SourceLocation getInnerLocStart() const
getInnerLocStart - Return SourceLocation representing start of source range ignoring outer template d...
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization, retrieves the member specialization information.
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
bool InstantiateInClassInitializer(SourceLocation PointOfInstantiation, FieldDecl *Instantiation, FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the definition of a field from the given pattern.
delayed_partial_spec_iterator delayed_partial_spec_begin()
Return an iterator to the beginning of the set of "delayed" partial specializations, which must be passed to InstantiateClassTemplatePartialSpecialization once the class definition has been completed.
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, Optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(NamedDecl *D, const TemplateArgumentList *Innermost=nullptr, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Expr - This represents one expression.
Defines the clang::LangOptions interface.
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
VarDecl * getOutOfLineDefinition()
If this is a static data member, find its out-of-line definition.
bool hasFatalErrorOccurred() const
void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
Declaration of a template type parameter.
ClassTemplatePartialSpecializationDecl * InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl *ClassTemplate, ClassTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a class template partial specialization.
void PerformDependentDiagnostics(const DeclContext *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
This file defines the classes used to store parsed information about declaration-specifiers and decla...
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
ExprResult BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc)
Given a non-type template argument that refers to a declaration and the type of its corresponding non...
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
TranslationUnitDecl * getTranslationUnitDecl() const
bool InNonInstantiationSFINAEContext
Whether we are in a SFINAE context that is not associated with template instantiation.
SourceLocation getLocation() const
ArgKind getKind() const
Return the kind of stored template argument.
ExtProtoInfo getExtProtoInfo() const
ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, Optional< unsigned > NumExpansions, bool ExpectParameterPack)
DeclContext * getDeclContext()
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, Expr *Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member, and after instantiating an in-class initializer in a class template.
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
QualType getType() const
Get the type for which this source info wrapper provides information.
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
void CheckCompletedCXXClass(CXXRecordDecl *Record)
Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations()
Retrieve the set of partial specializations of this class template.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Data structure that captures multiple levels of template argument lists for use in template instantia...
SmallVector< ActiveTemplateInstantiation, 16 > ActiveTemplateInstantiations
List of active template instantiations.
void setLocation(SourceLocation L)
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
Represents a reference to a non-type template parameter that has been substituted with a template arg...
class LLVM_ALIGNAS(8) TemplateSpecializationType unsigned NumArgs
Represents a type template specialization; the template must be a class template, a type alias templa...
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
SourceLocation getLocEnd() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
SourceLocation getParameterPackLocation() const
Retrieve the location of the parameter pack name.
const TypeClass * getTypePtr() const
Attr * instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
static void deleteScopes(LocalInstantiationScope *Scope, LocalInstantiationScope *Outermost)
deletes the given scope, and all otuer scopes, down to the given outermost scope. ...
ActiveTemplateInstantiation()
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
ExceptionSpecificationType Type
The kind of exception specification this is.
A stack object to be created when performing template instantiation.
bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, TemplateArgumentListInfo &Result, const MultiLevelTemplateArgumentList &TemplateArgs)
unsigned getNumLevels() const
Determine the number of levels in this template argument list.
Encodes a location in the source.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
const TemplateArgument * iterator
QualType getExpansionType(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
A structure for storing an already-substituted template template parameter pack.
void InstantiateStaticDataMemberDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false)
Instantiate the definition of the given variable from its template.
SmallVectorImpl< std::pair< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > >::iterator delayed_var_partial_spec_iterator
TagDecl - Represents the declaration of a struct/union/class/enum.
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
void printName(raw_ostream &os) const
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
Represents a static or instance method of a struct/union/class.
SourceLocation getNameLoc() const
void set(Decl *Spec, DeductionFailureInfo Info)
void reserve(size_t Requested)
Ensures that this buffer has at least as much capacity as described.
static const Decl * getCanonicalParmVarDecl(const Decl *D)
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, sema::TemplateDeductionInfo &Info)
Perform template argument deduction to determine whether the given template arguments match the given...
bool isInstantiationRecord() const
Determines whether this template is an actual instantiation that should be counted toward the maximum...
void setTagKind(TagKind TK)
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
ParmVarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
This template specialization was instantiated from a template due to an explicit instantiation defini...
bool isFileContext() const
Represents a C++11 static_assert declaration.
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization, returns the templated static data member from which it was instantiated.
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema's representation of template deduction information to the form used in overload-can...
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, AttributeList *AttrList)
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
void setHasInheritedDefaultArg(bool I=true)
QualType getType() const
Return the type wrapped by this type source info.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
void InstantiateClassTemplateSpecializationMembers(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK)
Instantiate the definitions of all of the members of the given class template specialization, which was named as part of an explicit instantiation.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template...
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
Represents a reference to a function parameter pack that has been substituted but not yet expanded...
Represents a template argument.
QualType getAsType() const
Retrieve the type for a type template argument.
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument. ...
Represents a template name that was expressed as a qualified name.
TagTypeKind
The kind of a tag type.
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
bool SubstParmTypes(SourceLocation Loc, ParmVarDecl **Params, unsigned NumParams, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< QualType > &ParamTypes, SmallVectorImpl< ParmVarDecl * > *OutParams=nullptr)
Substitute the given template arguments into the given set of parameters, producing the set of parame...
[C99 6.4.2.2] - A predefined identifier such as func.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
LocalInstantiationScope * getStartingScope() const
The base class of all kinds of template declarations (e.g., class, function, etc.).
A template instantiation that is currently in progress.
bool hasUnparsedDefaultArg() const
hasUnparsedDefaultArg - Determines whether this parameter has a default argument that has not yet bee...
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
bool isInvalidDecl() const
delayed_partial_spec_iterator delayed_partial_spec_end()
Return an iterator to the end of the set of "delayed" partial specializations, which must be passed t...
TypeLoc IgnoreParens() const
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
This template specialization was instantiated from a template due to an explicit instantiation declar...
bool isParameterPack() const
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
DeclarationName - The name of a declaration.
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 setInstantiationOfMemberFunction(FunctionDecl *FD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member function FD.
bool isNull() const
Determine whether this template argument has no value.
bool isDefinedOutsideFunctionOrMethod() const
isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...
EnumDecl - Represents an enum.
unsigned getFunctionScopeDepth() const
detail::InMemoryDirectory::const_iterator E
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
SourceLocation getParameterPackLocation() const
Get the location of the parameter pack.
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false)
Instantiate the definition of the given function from its template.
unsigned getDepth() const
Get the nesting depth of the template parameter.
bool hasInheritedDefaultArg() const
Location wrapper for a TemplateArgument.
void setUnparsedDefaultArg()
setUnparsedDefaultArg - Specify that this parameter has an unparsed default argument.
Expr * getUninstantiatedDefaultArg()
const T * getAs() const
Member-template getAs<specific type>'.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
This template specialization was declared or defined by an explicit specialization (C++ [temp...
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
static std::pair< unsigned, unsigned > getDepthAndIndex(NamedDecl *ND)
Retrieve the depth and index of a parameter pack.
QualType getIntegralType() const
Retrieve the type of the integral value.
bool isNull() const
Determine whether this template name is NULL.
UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations
A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...
The template argument is a type.
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
The template argument is actually a parameter pack.
bool isStaticDataMember() const
Determines whether this is a static data member.
Represents a base class of a C++ class.
bool isLexicallyWithinFunctionOrMethod() const
Returns true if this declaration lexically is inside a function.
static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, ParmVarDecl *ParamPack, SourceLocation NameLoc, ArrayRef< ParmVarDecl * > Params)
A template argument list.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
unsigned getFullDataSize() const
Returns the size of the type source info data block.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
NamedDecl * Template
The template (or partial specialization) in which we are performing the instantiation, for substitutions of prior template arguments.
Represents a C++ struct/union/class.
static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T)
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
void enableLateAttributeInstantiation(Sema::LateInstantiatedAttrVec *LA)
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 Clear()
Note that we have finished instantiating this template.
Provides information a specialization of a member of a class template, which may be a member function...
NamedDecl * FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs)
Find the instantiation of the given declaration within the current instantiation. ...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Declaration of a class template.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)
Returns the more specialized class template partial specialization according to the rules of partial ...
A reference to a declared variable, function, enum, etc.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
SourceLocation getInnerLocStart() const
getInnerLocStart - Return SourceLocation representing start of source range ignoring outer template d...
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
InstantiationKind
The kind of template instantiation we are performing.
We are instantiating the exception specification for a function template which was deferred until it ...
StringRef getKindName() const
Wrapper for template type parameters.
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
NamedDecl - This represents a decl with a name.
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization, retrieves the function from which it was instantiated.
EnumDecl * getDefinition() const
No keyword precedes the qualified type name.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
bool isBeingDefined() const
isBeingDefined - Return true if this decl is currently being defined.
ExceptionSpecInfo ExceptionSpec
Declaration of a template function.
Attr - This represents one attribute.
void setRBraceLoc(SourceLocation L)
const RecordDecl * getParent() const
getParent - Returns the parent of this field declaration, which is the struct in which this method is...
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
virtual void HandleTagDeclDefinition(TagDecl *D)
HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.
TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity)
Perform substitution on the type T with a given set of template arguments.
bool hasInClassInitializer() const
hasInClassInitializer - Determine whether this member has a C++11 in-class initializer.