30 using namespace clang;
57 bool RelativeToPrimary,
71 dyn_cast<VarTemplateSpecializationDecl>(D)) {
74 !isa<VarTemplatePartialSpecializationDecl>(Spec))
81 assert(Spec->getSpecializedTemplate() &&
"No variable template?");
87 if (Partial->isMemberSpecialization())
90 VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
104 = dyn_cast<TemplateTemplateParmDecl>(D)) {
105 for (
unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I)
115 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
118 !isa<ClassTemplatePartialSpecializationDecl>(Spec))
125 assert(Spec->getSpecializedTemplate() &&
"No class template?");
126 if (Spec->getSpecializedTemplate()->isMemberSpecialization())
130 else if (
FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
131 if (!RelativeToPrimary &&
132 (Function->getTemplateSpecializationKind() ==
134 !Function->getClassScopeSpecializationPattern()))
138 = Function->getTemplateSpecializationArgs()) {
144 assert(Function->getPrimaryTemplate() &&
"No function template?");
145 if (Function->getPrimaryTemplate()->isMemberSpecialization())
153 = Function->getDescribedFunctionTemplate()) {
162 if (Function->getFriendObjectKind() &&
163 Function->getDeclContext()->isFileContext() &&
165 Ctx = Function->getLexicalDeclContext();
166 RelativeToPrimary =
false;
169 }
else if (
CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
171 QualType T = ClassTemplate->getInjectedClassNameSpecialization();
176 if (ClassTemplate->isMemberSpecialization())
182 RelativeToPrimary =
false;
190 case TemplateInstantiation:
191 case ExceptionSpecInstantiation:
192 case DefaultTemplateArgumentInstantiation:
193 case DefaultFunctionArgumentInstantiation:
194 case ExplicitTemplateArgumentSubstitution:
195 case DeducedTemplateArgumentSubstitution:
196 case PriorTemplateArgumentSubstitution:
199 case DefaultTemplateArgumentChecking:
200 case DeclaringSpecialMember:
201 case DefiningSynthesizedFunction:
209 llvm_unreachable(
"Invalid SynthesisKind!");
226 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
239 AlreadyInstantiating =
252 PointOfInstantiation, InstantiationRange, Entity) {}
259 PointOfInstantiation, InstantiationRange, Entity) {}
269 Template, TemplateArgs) {}
278 InstantiationRange, FunctionTemplate, nullptr,
279 TemplateArgs, &DeductionInfo) {
293 PointOfInstantiation, InstantiationRange, Template, nullptr,
294 TemplateArgs, &DeductionInfo) {}
304 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
305 TemplateArgs, &DeductionInfo) {}
315 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
316 TemplateArgs, &DeductionInfo) {}
324 PointOfInstantiation, InstantiationRange, Param, nullptr,
334 PointOfInstantiation, InstantiationRange, Param, Template,
344 PointOfInstantiation, InstantiationRange, Param, Template,
353 PointOfInstantiation, InstantiationRange, Param, Template,
368 if (!Active.isInstantiationRecord()) {
378 "forgot to remove a lookup module for a template instantiation");
397 if (!AlreadyInstantiating) {
400 std::make_pair(Active.Entity, Active.Kind));
411 bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
421 SemaRef.
Diag(PointOfInstantiation,
422 diag::err_template_recursion_depth_exceeded)
424 << InstantiationRange;
425 SemaRef.
Diag(PointOfInstantiation, diag::note_template_recursion_depth)
437 SkipStart = Limit / 2 + Limit % 2;
442 unsigned InstantiationIdx = 0;
447 ++Active, ++InstantiationIdx) {
449 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
450 if (InstantiationIdx == SkipStart) {
453 diag::note_instantiation_contexts_suppressed)
459 switch (Active->Kind) {
461 Decl *D = Active->Entity;
463 unsigned DiagID = diag::note_template_member_class_here;
464 if (isa<ClassTemplateSpecializationDecl>(Record))
465 DiagID = diag::note_template_class_instantiation_here;
467 << Record << Active->InstantiationRange;
468 }
else if (
FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
470 if (Function->getPrimaryTemplate())
471 DiagID = diag::note_function_template_spec_here;
473 DiagID = diag::note_template_member_function_here;
476 << Active->InstantiationRange;
477 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
479 VD->isStaticDataMember()?
480 diag::note_template_static_data_member_def_here
481 : diag::note_template_variable_def_here)
483 << Active->InstantiationRange;
484 }
else if (
EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
486 diag::note_template_enum_def_here)
488 << Active->InstantiationRange;
489 }
else if (
FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
491 diag::note_template_nsdmi_here)
492 << FD << Active->InstantiationRange;
495 diag::note_template_type_alias_instantiation_here)
496 << cast<TypeAliasTemplateDecl>(D)
497 << Active->InstantiationRange;
503 TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
505 llvm::raw_svector_ostream OS(TemplateArgsStr);
510 diag::note_default_arg_instantiation_here)
512 << Active->InstantiationRange;
519 diag::note_explicit_template_arg_substitution_here)
522 Active->TemplateArgs,
523 Active->NumTemplateArgs)
524 << Active->InstantiationRange;
530 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
532 diag::note_function_template_deduction_instantiation_here)
535 Active->TemplateArgs,
536 Active->NumTemplateArgs)
537 << Active->InstantiationRange;
539 bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
540 isa<VarTemplateSpecializationDecl>(Active->Entity);
541 bool IsTemplate =
false;
543 if (
auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
545 Params = D->getTemplateParameters();
546 }
else if (
auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
548 Params = D->getTemplateParameters();
549 }
else if (
auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
551 Params = D->getTemplateParameters();
553 llvm_unreachable(
"unexpected template kind");
557 diag::note_deduced_template_arg_substitution_here)
558 << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
560 Active->NumTemplateArgs)
561 << Active->InstantiationRange;
567 ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
571 llvm::raw_svector_ostream OS(TemplateArgsStr);
576 diag::note_default_function_arg_instantiation_here)
578 << Active->InstantiationRange;
583 NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
586 Name = std::string(
" '") + Parm->
getName().str() +
"'";
589 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
590 TemplateParams = Template->getTemplateParameters();
593 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
594 ->getTemplateParameters();
596 diag::note_prior_template_arg_substitution)
597 << isa<TemplateTemplateParmDecl>(Parm)
600 Active->TemplateArgs,
601 Active->NumTemplateArgs)
602 << Active->InstantiationRange;
608 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
609 TemplateParams = Template->getTemplateParameters();
612 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
613 ->getTemplateParameters();
616 diag::note_template_default_arg_checking)
618 Active->TemplateArgs,
619 Active->NumTemplateArgs)
620 << Active->InstantiationRange;
626 diag::note_template_exception_spec_instantiation_here)
627 << cast<FunctionDecl>(Active->Entity)
628 << Active->InstantiationRange;
633 diag::note_in_declaration_of_implicit_special_member)
634 << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
639 auto *MD = dyn_cast<CXXMethodDecl>(Active->Entity);
643 diag::note_member_synthesized_at)
665 switch (Active->Kind) {
669 if (isa<TypeAliasTemplateDecl>(Active->Entity))
689 assert(Active->DeductionInfo &&
"Missing deduction info pointer");
690 return Active->DeductionInfo;
704 if (Active->SavedInNonInstantiationSFINAEContext)
715 class TemplateInstantiator :
public TreeTransform<TemplateInstantiator> {
723 TemplateInstantiator(
Sema &SemaRef,
727 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
735 bool AlreadyTransformed(
QualType T);
747 this->Entity = Entity;
753 bool &ShouldExpand,
bool &RetainExpansion,
755 return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
756 PatternRange, Unexpanded,
763 void ExpandingFunctionParameterPack(
ParmVarDecl *Pack) {
773 unsigned Depth, Index;
776 Result = TemplateArgs(Depth, Index);
792 unsigned Depth, Index;
802 void transformAttrs(
Decl *Old,
Decl *New) {
806 void transformedLocalDecl(
Decl *Old,
Decl *New) {
813 if (
auto *NewTD = NewMD->getDescribedFunctionTemplate())
814 NewTD->setInstantiatedFromMemberTemplate(
815 OldMD->getDescribedFunctionTemplate());
825 if (
auto *DC = dyn_cast<DeclContext>(Old))
861 NamedDecl *FirstQualifierInScope =
nullptr,
862 bool AllowInjectedClassName =
false);
864 const LoopHintAttr *TransformLoopHintAttr(
const LoopHintAttr *LH);
872 ExprResult TransformSubstNonTypeTemplateParmPackExpr(
890 return inherited::TransformFunctionProtoType(TLB, TL);
893 template<
typename Fn>
897 unsigned ThisTypeQuals,
898 Fn TransformExceptionSpec);
903 bool ExpectParameterPack);
923 if (!OrigTPL || !OrigTPL->
size())
return OrigTPL;
927 Owner, TemplateArgs);
937 bool TemplateInstantiator::AlreadyTransformed(
QualType T) {
944 getSema().MarkDeclarationsReferencedInType(Loc, T);
953 if (Arg.isPackExpansion())
963 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
968 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
974 if (TTP->isParameterPack()) {
976 "Missing argument pack");
982 "Wrong kind of template template argument");
994 Decl *Inst = getSema().SubstDecl(D, getSema().
CurContext, TemplateArgs);
998 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1003 TemplateInstantiator::TransformFirstQualifierInScope(
NamedDecl *D,
1009 = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));
1011 if (TTP->
getDepth() < TemplateArgs.getNumLevels()) {
1017 "Missing argument pack");
1019 if (getSema().ArgumentPackSubstitutionIndex == -1)
1027 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1030 return Tag->getDecl();
1033 getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
1038 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1042 TemplateInstantiator::RebuildExceptionDecl(
VarDecl *ExceptionDecl,
1047 VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
1048 StartLoc, NameLoc, Name);
1050 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1054 VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(
VarDecl *ExceptionDecl,
1057 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
1059 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1064 TemplateInstantiator::RebuildElaboratedType(
SourceLocation KeywordLoc,
1081 SemaRef.
Diag(TagLocation, diag::err_use_with_wrong_tag)
1096 TemplateName TemplateInstantiator::TransformTemplateName(
1099 bool AllowInjectedClassName) {
1102 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
1107 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
1108 TTP->getPosition()))
1113 if (TTP->isParameterPack()) {
1115 "Missing argument pack");
1117 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1121 return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
1128 assert(!Template.
isNull() &&
"Null template template argument");
1130 "template decl to substitute is qualified?");
1132 Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
1139 if (getSema().ArgumentPackSubstitutionIndex == -1)
1147 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
1148 FirstQualifierInScope,
1149 AllowInjectedClassName);
1153 TemplateInstantiator::TransformPredefinedExpr(
PredefinedExpr *E) {
1161 TemplateInstantiator::TransformTemplateParmRefExpr(
DeclRefExpr *E,
1167 if (!TemplateArgs.hasTemplateArgument(NTTP->
getDepth(),
1173 if (TemplateArgs.getNumLevels() != TemplateArgs.getNumSubstitutedLevels()) {
1181 "unexpected pack arguments in partial substitution");
1185 "unexpected nontype template argument kind in partial substitution");
1191 "Missing argument pack");
1193 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1212 return transformNonTypeTemplateParmRef(NTTP, E->
getLocation(), Arg);
1215 const LoopHintAttr *
1216 TemplateInstantiator::TransformLoopHintAttr(
const LoopHintAttr *LH) {
1217 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).
get();
1219 if (TransformedExpr == LH->getValue())
1223 if (getSema().CheckLoopHintExpr(TransformedExpr, LH->getLocation()))
1228 return LoopHintAttr::CreateImplicit(
1229 getSema().
Context, LH->getSemanticSpelling(), LH->getOption(),
1230 LH->getState(), TransformedExpr, LH->getRange());
1233 ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
1255 VD = cast_or_null<ValueDecl>(
1256 getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
1269 isa<PackExpansionType>(parm->
getType())) {
1271 cast<PackExpansionType>(parm->
getType())->getPattern(),
1277 assert(!type.
isNull() &&
"type substitution failed for param type");
1281 if (!result.isInvalid()) type = result.get()->getType();
1291 Expr *resultExpr = result.
get();
1293 type, resultExpr->
getValueKind(), loc, parm, resultExpr);
1297 TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
1312 TemplateInstantiator::RebuildParmVarDeclRefExpr(
ParmVarDecl *PD,
1315 return getSema().BuildDeclarationNameExpr(
CXXScopeSpec(), NameInfo, PD);
1326 return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(VD), E->
getExprLoc());
1340 cast_or_null<ParmVarDecl>(TransformDecl(E->
getExprLoc(), *I));
1352 TemplateInstantiator::TransformFunctionParmPackRefExpr(
DeclRefExpr *E,
1355 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
1356 = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
1357 assert(Found &&
"no instantiation for parameter pack");
1359 Decl *TransformedDecl;
1360 if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
1371 TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
1373 TransformedDecl = Found->get<
Decl*>();
1377 return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(TransformedDecl),
1382 TemplateInstantiator::TransformDeclRefExpr(
DeclRefExpr *E) {
1388 if (NTTP->
getDepth() < TemplateArgs.getNumLevels())
1389 return TransformTemplateParmRefExpr(E, NTTP);
1398 return TransformFunctionParmPackRefExpr(E, PD);
1403 ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
1406 getDescribedFunctionTemplate() &&
1407 "Default arg expressions are never formed in dependent cases.");
1413 template<
typename Fn>
1417 unsigned ThisTypeQuals,
1418 Fn TransformExceptionSpec) {
1421 return inherited::TransformFunctionProtoType(
1422 TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
1426 TemplateInstantiator::TransformFunctionTypeParam(
ParmVarDecl *OldParm,
1427 int indexAdjustment,
1429 bool ExpectParameterPack) {
1431 NumExpansions, ExpectParameterPack);
1435 TemplateInstantiator::TransformTemplateTypeParmType(
TypeLocBuilder &TLB,
1438 if (T->
getDepth() < TemplateArgs.getNumLevels()) {
1457 "Missing argument pack");
1459 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1464 = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
1475 "Template argument kind mismatch");
1481 = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
1494 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
1506 TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
1521 Result = getSema().Context.getSubstTemplateTypeParmType(
1564 bool AllowDeducedTST) {
1566 "Cannot perform an instantiation without some context on the " 1567 "instantiation stack");
1573 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1574 return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(T)
1575 : Instantiator.TransformType(T);
1583 "Cannot perform an instantiation without some context on the " 1584 "instantiation stack");
1598 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1613 "Cannot perform an instantiation without some context on the " 1614 "instantiation stack");
1621 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc, Entity);
1622 return Instantiator.TransformType(T);
1656 unsigned ThisTypeQuals) {
1658 "Cannot perform an instantiation without some context on the " 1659 "instantiation stack");
1664 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1680 Result = Instantiator.TransformFunctionProtoType(
1681 TLB, Proto, ThisContext, ThisTypeQuals,
1683 bool &Changed) {
return false; });
1685 Result = Instantiator.TransformType(TLB, TL);
1699 bool Changed =
false;
1700 TemplateInstantiator Instantiator(*
this, Args, Loc,
DeclarationName());
1701 return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
1712 ESI, ExceptionStorage, Args))
1721 int indexAdjustment,
1723 bool ExpectParameterPack) {
1732 NewDI =
SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
1743 }
else if (ExpectParameterPack) {
1749 diag::err_function_parameter_pack_without_parameter_packs)
1836 "Cannot perform an instantiation without some context on the " 1837 "instantiation stack");
1839 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
1841 return Instantiator.TransformFunctionTypeParams(
1842 Loc, Params,
nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
1855 bool Invalid =
false;
1857 for (
const auto &
Base : Pattern->
bases()) {
1858 if (!
Base.getType()->isDependentType()) {
1860 if (RD->isInvalidDecl())
1869 if (
Base.isPackExpansion()) {
1875 bool ShouldExpand =
false;
1876 bool RetainExpansion =
false;
1879 Base.getSourceRange(),
1881 TemplateArgs, ShouldExpand,
1890 for (
unsigned I = 0; I != *NumExpansions; ++I) {
1895 Base.getSourceRange().getBegin(),
1904 Base.getSourceRange(),
1906 Base.getAccessSpecifierAsWritten(),
1909 InstantiatedBases.push_back(InstantiatedBase);
1918 EllipsisLoc =
Base.getEllipsisLoc();
1922 Base.getSourceRange().getBegin(),
1927 Base.getSourceRange().getBegin(),
1938 Base.getSourceRange(),
1940 Base.getAccessSpecifierAsWritten(),
1943 InstantiatedBases.push_back(InstantiatedBase);
1997 Pattern, PatternDef, TSK, Complain))
1999 Pattern = PatternDef;
2005 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2007 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
2008 Spec->setTemplateSpecializationKind(TSK);
2009 Spec->setPointOfInstantiation(PointOfInstantiation);
2017 "instantiating class definition");
2035 SavePendingParsedClassStateRAII SavedPendingParsedClassState(*
this);
2060 for (
auto *Member : Pattern->
decls()) {
2070 if (Member->getDeclContext() != Pattern)
2075 if (isa<BlockDecl>(Member))
2078 if (Member->isInvalidDecl()) {
2083 Decl *NewMember = Instantiator.
Visit(Member);
2085 if (
FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
2086 Fields.push_back(Field);
2087 }
else if (
EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
2093 Enum->isCompleteDefinition()) {
2095 assert(MSInfo &&
"no spec info for member enum specialization");
2100 if (SA->isFailed()) {
2129 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
2130 E = LateAttrs.end(); I != E; ++I) {
2143 I->NewDecl->addAttr(NewAttr);
2171 P->first,
P->second)) {
2184 P->first,
P->second)) {
2228 Pattern, PatternDef, TSK,
true))
2230 Pattern = PatternDef;
2236 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2245 "instantiating enum definition");
2295 "pattern and instantiation disagree about init style");
2303 Diag(PointOfInstantiation,
2304 diag::err_in_class_initializer_not_yet_parsed)
2305 << OutermostClass << Pattern;
2306 Diag(Pattern->getLocEnd(), diag::note_in_class_initializer_not_yet_parsed);
2316 Diag(PointOfInstantiation, diag::err_in_class_initializer_cycle)
2321 "instantiating default member init");
2337 Expr *Init = NewInit.get();
2338 assert((!Init || !isa<ParenListExpr>(Init)) &&
"call-style init in class");
2343 L->DefaultMemberInitializerInstantiated(Instantiation);
2352 struct PartialSpecMatchResult {
2367 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2404 typedef PartialSpecMatchResult MatchResult;
2409 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2421 Matched.push_back(PartialSpecMatchResult());
2422 Matched.back().Partial = Partial;
2423 Matched.back().Args = Info.take();
2431 if (Matched.size() >= 1) {
2433 if (Matched.size() == 1) {
2446 PEnd = Matched.end();
2449 P->Partial, Best->Partial, PointOfInstantiation) ==
2456 bool Ambiguous =
false;
2458 PEnd = Matched.end();
2461 P->Partial, Best->Partial,
2462 PointOfInstantiation) != Best->Partial) {
2472 S.
Diag(PointOfInstantiation,
2473 diag::err_partial_spec_ordering_ambiguous)
2474 << ClassTemplateSpec;
2478 PEnd = Matched.end();
2480 S.
Diag(
P->Partial->getLocation(), diag::note_partial_spec_match)
2482 P->Partial->getTemplateParameters(), *
P->Args);
2497 if (
auto *PartialSpec =
2500 while (PartialSpec->getInstantiatedFromMember()) {
2503 if (PartialSpec->isMemberSpecialization())
2506 PartialSpec = PartialSpec->getInstantiatedFromMember();
2508 Pattern = PartialSpec;
2530 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
2536 *
this, PointOfInstantiation, ClassTemplateSpec, TSK, Complain);
2560 "Unexpected template specialization kind!");
2561 for (
auto *D : Instantiation->
decls()) {
2562 bool SuppressNew =
false;
2563 if (
auto *Function = dyn_cast<FunctionDecl>(D)) {
2565 = Function->getInstantiatedFromMemberFunction()) {
2567 = Function->getMemberSpecializationInfo();
2568 assert(MSInfo &&
"No member specialization information?");
2590 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2592 if (Function->isDefined()) {
2600 std::make_pair(Function, PointOfInstantiation));
2603 }
else if (
auto *Var = dyn_cast<VarDecl>(D)) {
2604 if (isa<VarTemplateSpecializationDecl>(Var))
2607 if (Var->isStaticDataMember()) {
2609 assert(MSInfo &&
"No member specialization information?");
2629 if (!Var->getInstantiatedFromStaticDataMember()->getDefinition())
2632 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2635 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2638 }
else if (
auto *Record = dyn_cast<CXXRecordDecl>(D)) {
2644 if (Record->isInjectedClassName() || Record->getPreviousDecl() ||
2649 assert(MSInfo &&
"No member specialization information?");
2672 assert(Pattern &&
"Missing instantiated-from-template information");
2674 if (!Record->getDefinition()) {
2695 Record->getTemplateSpecializationKind() ==
2697 Record->setTemplateSpecializationKind(TSK);
2702 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
2706 }
else if (
auto *Enum = dyn_cast<EnumDecl>(D)) {
2708 assert(MSInfo &&
"No member specialization information?");
2715 PointOfInstantiation, TSK, Enum,
2721 if (Enum->getDefinition())
2724 EnumDecl *Pattern = Enum->getTemplateInstantiationPattern();
2725 assert(Pattern &&
"Missing instantiated-from-template information");
2731 InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
2736 }
else if (
auto *Field = dyn_cast<FieldDecl>(D)) {
2743 ClassPattern->
lookup(Field->getDeclName());
2778 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2781 return Instantiator.TransformStmt(S);
2789 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2792 return Instantiator.TransformExpr(E);
2797 bool CXXDirectInit) {
2798 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2801 return Instantiator.TransformInitializer(Init, CXXDirectInit);
2810 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2813 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
2823 TemplateInstantiator Instantiator(*
this, TemplateArgs, NNS.
getBeginLoc(),
2825 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
2832 TemplateInstantiator Instantiator(*
this, TemplateArgs, NameInfo.
getLoc(),
2834 return Instantiator.TransformDeclarationNameInfo(NameInfo);
2841 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
2844 SS.
Adopt(QualifierLoc);
2845 return Instantiator.TransformTemplateName(SS, Name, Loc);
2851 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
2854 return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
2862 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
2863 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
2864 unsigned i = PV->getFunctionScopeIndex();
2867 if (FD->getParamDecl(i) == PV)
2875 llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
2879 Current = Current->Outer) {
2882 const Decl *CheckD = D;
2884 LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
2885 if (Found != Current->LocalDecls.end())
2886 return &Found->second;
2890 if (
const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
2897 if (!Current->CombineWithOuterScope)
2903 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
2904 isa<TemplateTemplateParmDecl>(D))
2909 if (RD->isLocalClass())
2914 if (isa<EnumDecl>(D))
2920 assert(isa<LabelDecl>(D) &&
"declaration not instantiated in this scope");
2926 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2927 if (Stored.isNull()) {
2931 while (Current->CombineWithOuterScope && Current->Outer) {
2932 Current = Current->Outer;
2933 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
2934 "Instantiated local in inner and outer scopes");
2939 Pack->push_back(cast<ParmVarDecl>(Inst));
2941 assert(Stored.get<
Decl *>() == Inst &&
"Already instantiated this local");
2949 Pack->push_back(Inst);
2956 Current && Current->CombineWithOuterScope; Current = Current->Outer)
2957 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
2958 "Creating local pack after instantiation of local");
2962 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2965 ArgumentPacks.push_back(Pack);
2970 unsigned NumExplicitArgs) {
2971 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
2972 "Already have a partially-substituted pack");
2973 assert((!PartiallySubstitutedPack
2974 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
2975 "Wrong number of arguments in partially-substituted pack");
2976 PartiallySubstitutedPack = Pack;
2977 ArgsInPartiallySubstitutedPack = ExplicitArgs;
2978 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
2983 unsigned *NumExplicitArgs)
const {
2985 *ExplicitArgs =
nullptr;
2986 if (NumExplicitArgs)
2987 *NumExplicitArgs = 0;
2990 Current = Current->Outer) {
2991 if (Current->PartiallySubstitutedPack) {
2993 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
2994 if (NumExplicitArgs)
2995 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
2997 return Current->PartiallySubstitutedPack;
3000 if (!Current->CombineWithOuterScope)
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
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.
unsigned getTemplateBacktraceLimit() const
Retrieve the maximum number of template instantiation notes to emit along with a given diagnostic...
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 ...
We are defining a synthesized function (such as a defaulted special member).
Represents a function declaration or definition.
delayed_var_partial_spec_iterator delayed_var_partial_spec_begin()
no exception specification
const TypeClass * getTypePtr() const
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
SourceLocation getUsedLocation() const
Retrieve the location where this default argument was actually used.
A (possibly-)qualified type.
TemplateDeductionResult
Describes the result of template argument deduction.
void InstantiatedLocal(const Decl *D, Decl *Inst)
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
llvm::PointerUnion3< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
A stack-allocated class that identifies which local variable declaration instantiations are present i...
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained)...
SourceRange getBraceRange() const
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
void addOuterTemplateArguments(const TemplateArgumentList *TemplateArgs)
Add a new outermost level to the multi-level template argument list.
Decl * Entity
The entity that is being synthesized.
Stmt - This represents one statement.
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
ExprResult SubstInitializer(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs, bool CXXDirectInit)
Provides information about an attempted template argument deduction, whose success or failure was des...
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed...
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...
bool isInstantiationRecord() const
Determines whether this template is an actual instantiation that should be counted toward the maximum...
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()
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
SmallVector< Module *, 16 > CodeSynthesisContextLookupModules
Extra modules inspected when performing a lookup during a template instantiation. ...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined...
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...
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)
const TargetInfo & getTargetInfo() const
A container of type source information.
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...
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...
We are instantiating a default argument for a template parameter.
VarTemplatePartialSpecializationDecl * InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a variable template partial specialization.
TemplateTypeParmDecl * getDecl() const
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 CodeSynthesisContexts that are not template instantiations and, therefore, should not be counted as part of the instantiation depth.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
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.
LocalInstantiationScope * getStartingScope() 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).
unsigned getDepth() const
Get the nesting depth of the template parameter.
void InstantiatedLocalPackArg(const Decl *D, ParmVarDecl *Inst)
RAII object that enters a new expression evaluation context.
Represents a variable declaration or definition.
Information about one declarator, including the parsed type information and the identifier.
DiagnosticsEngine & Diags
const T * getAs() const
Member-template getAs<specific type>'.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
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.
bool hasInheritedDefaultArg() const
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
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...
bool isInvalidDecl() const
Stores a list of template parameters for a TemplateDecl and its derived classes.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Represents a parameter to a function.
QualType getIntegralType() const
Retrieve the type of the integral value.
const TemplateArgument * TemplateArgs
The list of template arguments we are substituting, if they are not part of the entity.
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
bool isLexicallyWithinFunctionOrMethod() const
Returns true if this declaration lexically is inside a function.
Base wrapper for a particular "section" of type source info.
Represents a struct/union/class.
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
void PrintInstantiationStack()
Prints the current instantiation stack through a series of notes.
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...
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
TemplateName getNameToSubstitute() const
Get the template name to substitute when this template name is used as a template template argument...
Expr * getAsExpr() const
Retrieve the template argument as an expression.
void setUninstantiatedDefaultArg(Expr *arg)
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.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
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...
Represents a member of a struct/union/class.
The current expression is potentially evaluated at run time, which means that code may be generated t...
void setArgument(unsigned Depth, unsigned Index, TemplateArgument Arg)
Clear out a specific template argument.
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
NamedDecl * Template
The template (or partial specialization) in which we are performing the instantiation, for substitutions of prior template arguments.
void startDefinition()
Starts the definition of this tag declaration.
bool usesPartialOrExplicitSpecialization(SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec)
bool isReferenceType() const
Interesting information about a specific parameter that can't simply be reflected in parameter's type...
bool isDefinedOutsideFunctionOrMethod() const
isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
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.
void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)
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()
QualType getParamTypeForDecl() const
Describes a module or submodule.
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
We are instantiating the exception specification for a function template which was deferred until it ...
unsigned getNumExpansions() const
Get the number of parameters in this parameter pack.
void setNameLoc(SourceLocation Loc)
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For an enumeration member that was instantiated from a member enumeration of a templated class...
TagKind getTagKind() const
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
SourceLocation getParameterPackLocation() const
Retrieve the location of the parameter pack name.
A convenient class for passing around template argument information.
static TemplateArgument getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg)
StmtResult SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs)
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
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...
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Wrapper for substituted template type parameters.
unsigned LastEmittedCodeSynthesisContextDepth
The depth of the context stack at the point when the most recent error or warning was produced...
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization...
void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this class template specialization is actually an instantiation of the given class 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.
const TemplateArgument * getArgs() const
Retrieve the template arguments.
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
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)...
QualType getExpansionType(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
const LangOptions & getLangOpts() const
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.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
A default argument (C++ [dcl.fct.default]).
void setLocStart(SourceLocation L)
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
RAII object used to change the argument pack substitution index within a Sema object.
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
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.
A helper class for building up ExtParameterInfos.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
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)
We are substituting explicit template arguments provided for a function template. ...
Sema - This implements semantic analysis and AST building for C.
Represents a prototype with parameter type info, e.g.
bool InstantiateEnum(SourceLocation PointOfInstantiation, EnumDecl *Instantiation, EnumDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiate the definition of an enum from a given pattern.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
std::pair< unsigned, unsigned > getDepthAndIndex(NamedDecl *ND)
Retrieve the depth and index of a template parameter.
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...
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
SourceLocation getLocation() const
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl *> Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
We are instantiating a template declaration.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Added for Template instantiation observation.
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.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, Optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
unsigned getFunctionScopeDepth() const
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...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Expr - This represents one expression.
Defines the clang::LangOptions interface.
StringRef getKindName() const
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
bool hasUncompilableErrorOccurred() const
Errors that actually prevent compilation, not those that are upgraded from a warning by -Werror...
Declaration of a template type parameter.
unsigned getIndex() const
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...
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
We are substituting template argument determined as part of template argument deduction for either a ...
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...
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
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...
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
bool InNonInstantiationSFINAEContext
Whether we are in a SFINAE context that is not associated with template instantiation.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
bool isFileContext() const
ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, Optional< unsigned > NumExpansions, bool ExpectParameterPack)
DeclContext * getDeclContext()
CXXRecordDecl * getDefinition() const
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.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
EnumDecl * getDefinition() const
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the class template or class template partial specialization which was specialized by this...
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
void CheckCompletedCXXClass(CXXRecordDecl *Record)
Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...
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...
void setLocation(SourceLocation L)
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization, retrieves the member specialization information.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Represents a reference to a non-type template parameter that has been substituted with a template arg...
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
SourceLocation getLocation() const
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
SourceLocation getLocEnd() const LLVM_READONLY
ParmVarDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
NamedDecl * FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, bool FindingInstantiatedContext=false)
Find the instantiation of the given declaration within the current instantiation. ...
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
Attr * instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
static void deleteScopes(LocalInstantiationScope *Scope, LocalInstantiationScope *Outermost)
deletes the given scope, and all otuer scopes, down to the given outermost scope. ...
virtual void printName(raw_ostream &os) const
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
We are declaring an implicit special member function.
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
ExceptionSpecificationType Type
The kind of exception specification this is.
TypeLoc IgnoreParens() const
A stack object to be created when performing template instantiation.
Attr * instantiateTemplateAttributeForDecl(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
ExtProtoInfo getExtProtoInfo() const
bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, TemplateArgumentListInfo &Result, const MultiLevelTemplateArgumentList &TemplateArgs)
Encodes a location in the source.
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
void setBraceRange(SourceRange R)
sema::TemplateDeductionInfo * DeductionInfo
The template deduction info object associated with the substitution or checking of explicit or deduce...
A structure for storing an already-substituted template template parameter pack.
DeclarationName getName() const
getName - Returns the embedded declaration name.
Represents the declaration of a struct/union/class/enum.
TemplateArgument getArgumentPack() const
TemplateParameterList * SubstTemplateParams(TemplateParameterList *List)
Instantiates a nested template parameter list in the current instantiation context.
SourceLocation getLocStart() const LLVM_READONLY
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set...
SynthesisKind
The kind of template instantiation we are performing.
Represents a static or instance method of a struct/union/class.
We are checking the validity of a default template argument that has been used when naming a template...
bool isParameterPack() const
void reserve(size_t Requested)
Ensures that this buffer has at least as much capacity as described.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
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...
void setTagKind(TagKind TK)
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
llvm::DenseSet< std::pair< Decl *, unsigned > > InstantiatingSpecializations
Specializations whose definitions are currently being instantiated.
bool hasUninstantiatedDefaultArg() const
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...
IdentType getIdentType() const
Represents a C++11 static_assert declaration.
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...
ArrayRef< ParmVarDecl * > getParams() const
unsigned getFullDataSize() const
Returns the size of the type source info data block.
bool hasTemplateArgument(unsigned Depth, unsigned Index) const
Determine whether there is a non-NULL template argument at the given depth and index.
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
ParmVarDecl * getExpansion(unsigned I) const
Get an expansion of the parameter pack by index.
void setHasInheritedDefaultArg(bool I=true)
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
getSpecialMember - get the special member enum for a method.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
SourceLocation getLocation() const
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.
Represents a reference to a function parameter pack that has been substituted but not yet expanded...
Represents a template argument.
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument. ...
TagTypeKind
The kind of a tag type.
bool isNull() const
Determine whether this template name is NULL.
Dataflow Directional Tag Classes.
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
[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...
The base class of all kinds of template declarations (e.g., class, function, etc.).
ASTMutationListener * getASTMutationListener() const
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.
We are instantiating a default argument for a function.
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...
This template specialization was instantiated from a template due to an explicit instantiation declar...
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
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.
SourceRange InstantiationRange
The source range that covers the construct that cause the instantiation, e.g., the template-id that c...
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
SourceLocation getParameterPackLocation() const
Get the location of the parameter pack.
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...
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
bool isNull() const
Determine whether this template argument has no value.
Location wrapper for a TemplateArgument.
unsigned getNumArgs() const
Retrieve the number of template arguments.
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
Expr * getUninstantiatedDefaultArg()
This template specialization was declared or defined by an explicit specialization (C++ [temp...
TypeSourceInfo * getTypeSourceInfo() const
UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations
A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...
The template argument is a type.
SmallVectorImpl< std::pair< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > >::iterator delayed_var_partial_spec_iterator
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
The template argument is actually a parameter pack.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Represents a base class of a C++ class.
bool SavedInNonInstantiationSFINAEContext
Was the enclosing context a non-instantiation SFINAE context?
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool isAlreadyInstantiating() const
Determine whether we are already instantiating this specialization in some surrounding active instant...
A template argument list.
bool hasFatalErrorOccurred() const
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
ArgKind getKind() const
Return the kind of stored template argument.
unsigned getDepth() const
TranslationUnitDecl * getTranslationUnitDecl() const
Represents a C++ struct/union/class.
static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T)
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier *> Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
void enableLateAttributeInstantiation(Sema::LateInstantiatedAttrVec *LA)
void popCodeSynthesisContext()
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...
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
SmallVectorImpl< std::pair< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > >::iterator delayed_partial_spec_iterator
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...
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
SourceLocation getNameLoc() const
We are substituting prior template arguments into a new template parameter.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)
Returns the more specialized class template partial specialization according to the rules of partial ...
static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, ParmVarDecl *ParamPack, SourceLocation NameLoc, ArrayRef< ParmVarDecl *> Params)
const ParmVarDecl * getParam() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
QualType getAsType() const
Retrieve the type for a type template argument.
A reference to a declared variable, function, enum, etc.
Represents a type template specialization; the template must be a class template, a type alias templa...
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
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.
SourceLocation getInnerLocStart() const
Return SourceLocation representing start of source range ignoring outer template declarations.
ParmVarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
An l-value expression is a reference to an object with independent storage.
Wrapper for template type parameters.
A trivial tuple used to represent a source range.
This represents a decl that may have a name.
bool isTranslationUnit() const
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
NamedDecl * getAsNamedDecl(TemplateParameter P)
No keyword precedes the qualified type name.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
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...
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
bool isParameterPack() const
Determine whether this parameter is actually a function parameter pack.
ExceptionSpecInfo ExceptionSpec
Declaration of a template function.
Attr - This represents one attribute.
SourceLocation getLocation() const
QualType getType() const
Return the type wrapped by this type source info.
virtual void HandleTagDeclDefinition(TagDecl *D)
HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
static CXXRecordDecl * getPatternForClassTemplateSpecialization(Sema &S, SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain)
Get the instantiation pattern to use to instantiate the definition of a given ClassTemplateSpecializa...