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:
202 case ExceptionSpecEvaluation:
210 llvm_unreachable(
"Invalid SynthesisKind!");
227 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
240 AlreadyInstantiating =
253 PointOfInstantiation, InstantiationRange, Entity) {}
260 PointOfInstantiation, InstantiationRange, Entity) {}
270 Template, TemplateArgs) {}
279 InstantiationRange, FunctionTemplate, nullptr,
280 TemplateArgs, &DeductionInfo) {
294 PointOfInstantiation, InstantiationRange, Template, nullptr,
295 TemplateArgs, &DeductionInfo) {}
305 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
306 TemplateArgs, &DeductionInfo) {}
316 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
317 TemplateArgs, &DeductionInfo) {}
325 PointOfInstantiation, InstantiationRange, Param, nullptr,
335 PointOfInstantiation, InstantiationRange, Param, Template,
345 PointOfInstantiation, InstantiationRange, Param, Template,
354 PointOfInstantiation, InstantiationRange, Param, Template,
369 if (!Active.isInstantiationRecord()) {
379 "forgot to remove a lookup module for a template instantiation");
398 if (!AlreadyInstantiating) {
401 std::make_pair(Active.Entity, Active.Kind));
412 bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
422 SemaRef.
Diag(PointOfInstantiation,
423 diag::err_template_recursion_depth_exceeded)
425 << InstantiationRange;
426 SemaRef.
Diag(PointOfInstantiation, diag::note_template_recursion_depth)
438 SkipStart = Limit / 2 + Limit % 2;
443 unsigned InstantiationIdx = 0;
448 ++Active, ++InstantiationIdx) {
450 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
451 if (InstantiationIdx == SkipStart) {
454 diag::note_instantiation_contexts_suppressed)
460 switch (Active->Kind) {
462 Decl *D = Active->Entity;
464 unsigned DiagID = diag::note_template_member_class_here;
465 if (isa<ClassTemplateSpecializationDecl>(Record))
466 DiagID = diag::note_template_class_instantiation_here;
468 << Record << Active->InstantiationRange;
469 }
else if (
FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
471 if (Function->getPrimaryTemplate())
472 DiagID = diag::note_function_template_spec_here;
474 DiagID = diag::note_template_member_function_here;
477 << Active->InstantiationRange;
478 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
480 VD->isStaticDataMember()?
481 diag::note_template_static_data_member_def_here
482 : diag::note_template_variable_def_here)
484 << Active->InstantiationRange;
485 }
else if (
EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
487 diag::note_template_enum_def_here)
489 << Active->InstantiationRange;
490 }
else if (
FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
492 diag::note_template_nsdmi_here)
493 << FD << Active->InstantiationRange;
496 diag::note_template_type_alias_instantiation_here)
497 << cast<TypeAliasTemplateDecl>(D)
498 << Active->InstantiationRange;
504 TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
506 llvm::raw_svector_ostream OS(TemplateArgsStr);
511 diag::note_default_arg_instantiation_here)
513 << Active->InstantiationRange;
520 diag::note_explicit_template_arg_substitution_here)
523 Active->TemplateArgs,
524 Active->NumTemplateArgs)
525 << Active->InstantiationRange;
531 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
533 diag::note_function_template_deduction_instantiation_here)
536 Active->TemplateArgs,
537 Active->NumTemplateArgs)
538 << Active->InstantiationRange;
540 bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
541 isa<VarTemplateSpecializationDecl>(Active->Entity);
542 bool IsTemplate =
false;
544 if (
auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
546 Params = D->getTemplateParameters();
547 }
else if (
auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
549 Params = D->getTemplateParameters();
550 }
else if (
auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
552 Params = D->getTemplateParameters();
554 llvm_unreachable(
"unexpected template kind");
558 diag::note_deduced_template_arg_substitution_here)
559 << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
561 Active->NumTemplateArgs)
562 << Active->InstantiationRange;
568 ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
572 llvm::raw_svector_ostream OS(TemplateArgsStr);
577 diag::note_default_function_arg_instantiation_here)
579 << Active->InstantiationRange;
584 NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
587 Name = std::string(
" '") + Parm->
getName().str() +
"'";
590 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
591 TemplateParams = Template->getTemplateParameters();
594 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
595 ->getTemplateParameters();
597 diag::note_prior_template_arg_substitution)
598 << isa<TemplateTemplateParmDecl>(Parm)
601 Active->TemplateArgs,
602 Active->NumTemplateArgs)
603 << Active->InstantiationRange;
609 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
610 TemplateParams = Template->getTemplateParameters();
613 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
614 ->getTemplateParameters();
617 diag::note_template_default_arg_checking)
619 Active->TemplateArgs,
620 Active->NumTemplateArgs)
621 << Active->InstantiationRange;
627 diag::note_evaluating_exception_spec_here)
628 << cast<FunctionDecl>(Active->Entity);
633 diag::note_template_exception_spec_instantiation_here)
634 << cast<FunctionDecl>(Active->Entity)
635 << Active->InstantiationRange;
640 diag::note_in_declaration_of_implicit_special_member)
641 << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
646 auto *MD = dyn_cast<CXXMethodDecl>(Active->Entity);
650 diag::note_member_synthesized_at)
672 switch (Active->Kind) {
676 if (isa<TypeAliasTemplateDecl>(Active->Entity))
696 assert(Active->DeductionInfo &&
"Missing deduction info pointer");
697 return Active->DeductionInfo;
717 if (Active->SavedInNonInstantiationSFINAEContext)
728 class TemplateInstantiator :
public TreeTransform<TemplateInstantiator> {
736 TemplateInstantiator(
Sema &SemaRef,
740 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
748 bool AlreadyTransformed(
QualType T);
760 this->Entity = Entity;
766 bool &ShouldExpand,
bool &RetainExpansion,
768 return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
769 PatternRange, Unexpanded,
776 void ExpandingFunctionParameterPack(
ParmVarDecl *Pack) {
786 unsigned Depth, Index;
789 Result = TemplateArgs(Depth, Index);
805 unsigned Depth, Index;
815 void transformAttrs(
Decl *Old,
Decl *New) {
819 void transformedLocalDecl(
Decl *Old,
Decl *New) {
826 if (
auto *NewTD = NewMD->getDescribedFunctionTemplate())
827 NewTD->setInstantiatedFromMemberTemplate(
828 OldMD->getDescribedFunctionTemplate());
838 if (
auto *DC = dyn_cast<DeclContext>(Old))
874 NamedDecl *FirstQualifierInScope =
nullptr,
875 bool AllowInjectedClassName =
false);
877 const LoopHintAttr *TransformLoopHintAttr(
const LoopHintAttr *LH);
885 ExprResult TransformSubstNonTypeTemplateParmPackExpr(
903 return inherited::TransformFunctionProtoType(TLB, TL);
906 template<
typename Fn>
911 Fn TransformExceptionSpec);
916 bool ExpectParameterPack);
936 if (!OrigTPL || !OrigTPL->
size())
return OrigTPL;
940 Owner, TemplateArgs);
950 bool TemplateInstantiator::AlreadyTransformed(
QualType T) {
957 getSema().MarkDeclarationsReferencedInType(Loc, T);
966 if (Arg.isPackExpansion())
976 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
981 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
987 if (TTP->isParameterPack()) {
989 "Missing argument pack");
995 "Wrong kind of template template argument");
1007 Decl *Inst = getSema().SubstDecl(D, getSema().
CurContext, TemplateArgs);
1011 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1016 TemplateInstantiator::TransformFirstQualifierInScope(
NamedDecl *D,
1022 = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));
1024 if (TTP->
getDepth() < TemplateArgs.getNumLevels()) {
1030 "Missing argument pack");
1032 if (getSema().ArgumentPackSubstitutionIndex == -1)
1040 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1043 return Tag->getDecl();
1046 getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
1051 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1055 TemplateInstantiator::RebuildExceptionDecl(
VarDecl *ExceptionDecl,
1060 VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
1061 StartLoc, NameLoc, Name);
1063 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1067 VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(
VarDecl *ExceptionDecl,
1070 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
1072 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1077 TemplateInstantiator::RebuildElaboratedType(
SourceLocation KeywordLoc,
1094 SemaRef.
Diag(TagLocation, diag::err_use_with_wrong_tag)
1109 TemplateName TemplateInstantiator::TransformTemplateName(
1112 bool AllowInjectedClassName) {
1115 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
1120 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
1121 TTP->getPosition()))
1126 if (TTP->isParameterPack()) {
1128 "Missing argument pack");
1130 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1134 return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
1141 assert(!Template.
isNull() &&
"Null template template argument");
1143 "template decl to substitute is qualified?");
1145 Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
1152 if (getSema().ArgumentPackSubstitutionIndex == -1)
1160 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
1161 FirstQualifierInScope,
1162 AllowInjectedClassName);
1166 TemplateInstantiator::TransformPredefinedExpr(
PredefinedExpr *E) {
1174 TemplateInstantiator::TransformTemplateParmRefExpr(
DeclRefExpr *E,
1180 if (!TemplateArgs.hasTemplateArgument(NTTP->
getDepth(),
1186 if (TemplateArgs.getNumLevels() != TemplateArgs.getNumSubstitutedLevels()) {
1194 "unexpected pack arguments in partial substitution");
1198 "unexpected nontype template argument kind in partial substitution");
1204 "Missing argument pack");
1206 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1225 return transformNonTypeTemplateParmRef(NTTP, E->
getLocation(), Arg);
1228 const LoopHintAttr *
1229 TemplateInstantiator::TransformLoopHintAttr(
const LoopHintAttr *LH) {
1230 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).
get();
1232 if (TransformedExpr == LH->getValue())
1236 if (getSema().CheckLoopHintExpr(TransformedExpr, LH->getLocation()))
1241 return LoopHintAttr::CreateImplicit(
1242 getSema().
Context, LH->getSemanticSpelling(), LH->getOption(),
1243 LH->getState(), TransformedExpr, LH->getRange());
1246 ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
1268 VD = cast_or_null<ValueDecl>(
1269 getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
1282 isa<PackExpansionType>(parm->
getType())) {
1284 cast<PackExpansionType>(parm->
getType())->getPattern(),
1290 assert(!type.
isNull() &&
"type substitution failed for param type");
1294 if (!result.isInvalid()) type = result.get()->getType();
1304 Expr *resultExpr = result.
get();
1306 type, resultExpr->
getValueKind(), loc, parm, resultExpr);
1310 TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
1325 TemplateInstantiator::RebuildParmVarDeclRefExpr(
ParmVarDecl *PD,
1328 return getSema().BuildDeclarationNameExpr(
CXXScopeSpec(), NameInfo, PD);
1339 return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(VD), E->
getExprLoc());
1353 cast_or_null<ParmVarDecl>(TransformDecl(E->
getExprLoc(), *I));
1365 TemplateInstantiator::TransformFunctionParmPackRefExpr(
DeclRefExpr *E,
1368 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
1369 = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
1370 assert(Found &&
"no instantiation for parameter pack");
1372 Decl *TransformedDecl;
1373 if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
1384 TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
1386 TransformedDecl = Found->get<
Decl*>();
1390 return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(TransformedDecl),
1395 TemplateInstantiator::TransformDeclRefExpr(
DeclRefExpr *E) {
1401 if (NTTP->
getDepth() < TemplateArgs.getNumLevels())
1402 return TransformTemplateParmRefExpr(E, NTTP);
1411 return TransformFunctionParmPackRefExpr(E, PD);
1416 ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
1419 getDescribedFunctionTemplate() &&
1420 "Default arg expressions are never formed in dependent cases.");
1426 template<
typename Fn>
1431 Fn TransformExceptionSpec) {
1434 return inherited::TransformFunctionProtoType(
1435 TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
1439 TemplateInstantiator::TransformFunctionTypeParam(
ParmVarDecl *OldParm,
1440 int indexAdjustment,
1442 bool ExpectParameterPack) {
1444 NumExpansions, ExpectParameterPack);
1448 TemplateInstantiator::TransformTemplateTypeParmType(
TypeLocBuilder &TLB,
1451 if (T->
getDepth() < TemplateArgs.getNumLevels()) {
1470 "Missing argument pack");
1472 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1477 = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
1488 "Template argument kind mismatch");
1494 = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
1507 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
1519 TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
1534 Result = getSema().Context.getSubstTemplateTypeParmType(
1577 bool AllowDeducedTST) {
1579 "Cannot perform an instantiation without some context on the " 1580 "instantiation stack");
1586 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1587 return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(T)
1588 : Instantiator.TransformType(T);
1596 "Cannot perform an instantiation without some context on the " 1597 "instantiation stack");
1611 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1626 "Cannot perform an instantiation without some context on the " 1627 "instantiation stack");
1634 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc, Entity);
1635 return Instantiator.TransformType(T);
1671 "Cannot perform an instantiation without some context on the " 1672 "instantiation stack");
1677 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1693 Result = Instantiator.TransformFunctionProtoType(
1694 TLB, Proto, ThisContext, ThisTypeQuals,
1696 bool &Changed) {
return false; });
1698 Result = Instantiator.TransformType(TLB, TL);
1712 bool Changed =
false;
1713 TemplateInstantiator Instantiator(*
this, Args, Loc,
DeclarationName());
1714 return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
1725 ESI, ExceptionStorage, Args))
1734 int indexAdjustment,
1736 bool ExpectParameterPack) {
1745 NewDI =
SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
1756 }
else if (ExpectParameterPack) {
1762 diag::err_function_parameter_pack_without_parameter_packs)
1849 "Cannot perform an instantiation without some context on the " 1850 "instantiation stack");
1852 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
1854 return Instantiator.TransformFunctionTypeParams(
1855 Loc, Params,
nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
1868 bool Invalid =
false;
1870 for (
const auto &
Base : Pattern->
bases()) {
1871 if (!
Base.getType()->isDependentType()) {
1873 if (RD->isInvalidDecl())
1882 if (
Base.isPackExpansion()) {
1888 bool ShouldExpand =
false;
1889 bool RetainExpansion =
false;
1892 Base.getSourceRange(),
1894 TemplateArgs, ShouldExpand,
1903 for (
unsigned I = 0; I != *NumExpansions; ++I) {
1908 Base.getSourceRange().getBegin(),
1917 Base.getSourceRange(),
1919 Base.getAccessSpecifierAsWritten(),
1922 InstantiatedBases.push_back(InstantiatedBase);
1931 EllipsisLoc =
Base.getEllipsisLoc();
1935 Base.getSourceRange().getBegin(),
1940 Base.getSourceRange().getBegin(),
1951 Base.getSourceRange(),
1953 Base.getAccessSpecifierAsWritten(),
1956 InstantiatedBases.push_back(InstantiatedBase);
2010 Pattern, PatternDef, TSK, Complain))
2012 Pattern = PatternDef;
2018 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2020 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
2021 Spec->setTemplateSpecializationKind(TSK);
2022 Spec->setPointOfInstantiation(PointOfInstantiation);
2030 "instantiating class definition");
2048 SavePendingParsedClassStateRAII SavedPendingParsedClassState(*
this);
2073 for (
auto *Member : Pattern->
decls()) {
2083 if (Member->getDeclContext() != Pattern)
2088 if (isa<BlockDecl>(Member))
2091 if (Member->isInvalidDecl()) {
2096 Decl *NewMember = Instantiator.
Visit(Member);
2098 if (
FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
2099 Fields.push_back(Field);
2100 }
else if (
EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
2106 Enum->isCompleteDefinition()) {
2108 assert(MSInfo &&
"no spec info for member enum specialization");
2113 if (SA->isFailed()) {
2142 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
2143 E = LateAttrs.end(); I != E; ++I) {
2156 I->NewDecl->addAttr(NewAttr);
2184 P->first,
P->second)) {
2197 P->first,
P->second)) {
2241 Pattern, PatternDef, TSK,
true))
2243 Pattern = PatternDef;
2249 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2258 "instantiating enum definition");
2308 "pattern and instantiation disagree about init style");
2316 Diag(PointOfInstantiation,
2317 diag::err_in_class_initializer_not_yet_parsed)
2318 << OutermostClass << Pattern;
2319 Diag(Pattern->getEndLoc(), diag::note_in_class_initializer_not_yet_parsed);
2329 Diag(PointOfInstantiation, diag::err_in_class_initializer_cycle)
2334 "instantiating default member init");
2350 Expr *Init = NewInit.get();
2351 assert((!Init || !isa<ParenListExpr>(Init)) &&
"call-style init in class");
2356 L->DefaultMemberInitializerInstantiated(Instantiation);
2365 struct PartialSpecMatchResult {
2380 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2417 typedef PartialSpecMatchResult MatchResult;
2422 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2434 Matched.push_back(PartialSpecMatchResult());
2435 Matched.back().Partial = Partial;
2436 Matched.back().Args = Info.take();
2444 if (Matched.size() >= 1) {
2446 if (Matched.size() == 1) {
2459 PEnd = Matched.end();
2462 P->Partial, Best->Partial, PointOfInstantiation) ==
2469 bool Ambiguous =
false;
2471 PEnd = Matched.end();
2474 P->Partial, Best->Partial,
2475 PointOfInstantiation) != Best->Partial) {
2485 S.
Diag(PointOfInstantiation,
2486 diag::err_partial_spec_ordering_ambiguous)
2487 << ClassTemplateSpec;
2491 PEnd = Matched.end();
2493 S.
Diag(
P->Partial->getLocation(), diag::note_partial_spec_match)
2495 P->Partial->getTemplateParameters(), *
P->Args);
2510 if (
auto *PartialSpec =
2513 while (PartialSpec->getInstantiatedFromMember()) {
2516 if (PartialSpec->isMemberSpecialization())
2519 PartialSpec = PartialSpec->getInstantiatedFromMember();
2521 Pattern = PartialSpec;
2543 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
2549 *
this, PointOfInstantiation, ClassTemplateSpec, TSK, Complain);
2573 "Unexpected template specialization kind!");
2574 for (
auto *D : Instantiation->
decls()) {
2575 bool SuppressNew =
false;
2576 if (
auto *Function = dyn_cast<FunctionDecl>(D)) {
2578 Function->getInstantiatedFromMemberFunction()) {
2580 if (Function->hasAttr<ExcludeFromExplicitInstantiationAttr>())
2584 Function->getMemberSpecializationInfo();
2585 assert(MSInfo &&
"No member specialization information?");
2607 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2609 if (Function->isDefined()) {
2617 std::make_pair(Function, PointOfInstantiation));
2620 }
else if (
auto *Var = dyn_cast<VarDecl>(D)) {
2621 if (isa<VarTemplateSpecializationDecl>(Var))
2624 if (Var->isStaticDataMember()) {
2625 if (Var->hasAttr<ExcludeFromExplicitInstantiationAttr>())
2629 assert(MSInfo &&
"No member specialization information?");
2649 if (!Var->getInstantiatedFromStaticDataMember()->getDefinition())
2652 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2655 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2658 }
else if (
auto *Record = dyn_cast<CXXRecordDecl>(D)) {
2659 if (Record->hasAttr<ExcludeFromExplicitInstantiationAttr>())
2667 if (Record->isInjectedClassName() || Record->getPreviousDecl() ||
2672 assert(MSInfo &&
"No member specialization information?");
2695 assert(Pattern &&
"Missing instantiated-from-template information");
2697 if (!Record->getDefinition()) {
2718 Record->getTemplateSpecializationKind() ==
2720 Record->setTemplateSpecializationKind(TSK);
2725 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
2729 }
else if (
auto *Enum = dyn_cast<EnumDecl>(D)) {
2731 assert(MSInfo &&
"No member specialization information?");
2738 PointOfInstantiation, TSK, Enum,
2744 if (Enum->getDefinition())
2747 EnumDecl *Pattern = Enum->getTemplateInstantiationPattern();
2748 assert(Pattern &&
"Missing instantiated-from-template information");
2754 InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
2759 }
else if (
auto *Field = dyn_cast<FieldDecl>(D)) {
2766 ClassPattern->
lookup(Field->getDeclName());
2801 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2804 return Instantiator.TransformStmt(S);
2812 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2815 return Instantiator.TransformExpr(E);
2820 bool CXXDirectInit) {
2821 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2824 return Instantiator.TransformInitializer(Init, CXXDirectInit);
2833 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2836 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
2846 TemplateInstantiator Instantiator(*
this, TemplateArgs, NNS.
getBeginLoc(),
2848 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
2855 TemplateInstantiator Instantiator(*
this, TemplateArgs, NameInfo.
getLoc(),
2857 return Instantiator.TransformDeclarationNameInfo(NameInfo);
2864 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
2867 SS.
Adopt(QualifierLoc);
2868 return Instantiator.TransformTemplateName(SS, Name, Loc);
2874 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
2877 return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
2885 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
2886 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
2887 unsigned i = PV->getFunctionScopeIndex();
2890 if (FD->getParamDecl(i) == PV)
2898 llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
2902 Current = Current->Outer) {
2905 const Decl *CheckD = D;
2907 LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
2908 if (Found != Current->LocalDecls.end())
2909 return &Found->second;
2913 if (
const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
2920 if (!Current->CombineWithOuterScope)
2926 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
2927 isa<TemplateTemplateParmDecl>(D))
2932 if (RD->isLocalClass())
2937 if (isa<EnumDecl>(D))
2943 assert(isa<LabelDecl>(D) &&
"declaration not instantiated in this scope");
2949 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2950 if (Stored.isNull()) {
2954 while (Current->CombineWithOuterScope && Current->Outer) {
2955 Current = Current->Outer;
2956 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
2957 "Instantiated local in inner and outer scopes");
2962 Pack->push_back(cast<ParmVarDecl>(Inst));
2964 assert(Stored.get<
Decl *>() == Inst &&
"Already instantiated this local");
2972 Pack->push_back(Inst);
2979 Current && Current->CombineWithOuterScope; Current = Current->Outer)
2980 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
2981 "Creating local pack after instantiation of local");
2985 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2988 ArgumentPacks.push_back(Pack);
2993 unsigned NumExplicitArgs) {
2994 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
2995 "Already have a partially-substituted pack");
2996 assert((!PartiallySubstitutedPack
2997 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
2998 "Wrong number of arguments in partially-substituted pack");
2999 PartiallySubstitutedPack = Pack;
3000 ArgsInPartiallySubstitutedPack = ExplicitArgs;
3001 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
3006 unsigned *NumExplicitArgs)
const {
3008 *ExplicitArgs =
nullptr;
3009 if (NumExplicitArgs)
3010 *NumExplicitArgs = 0;
3013 Current = Current->Outer) {
3014 if (Current->PartiallySubstitutedPack) {
3016 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
3017 if (NumExplicitArgs)
3018 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
3020 return Current->PartiallySubstitutedPack;
3023 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...
IdentKind getIdentKind() const
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.
SourceLocation getEndLoc() const
Get the end source location.
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.
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.
The collection of all-type qualifiers we support.
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.
SourceLocation getBeginLoc() const LLVM_READONLY
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
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. ...
TypeSourceInfo * SubstFunctionDeclType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext, Qualifiers ThisTypeQuals)
A form of SubstType intended specifically for instantiating the type of a FunctionDecl.
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 ...
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.
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.
We are computing the exception specification for a defaulted special member function.
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.
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...
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...
Interesting information about a specific parameter that can't simply be reflected in parameter's type...
This template specialization was instantiated from a template due to an explicit instantiation declar...
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
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.
Holds information about the various types of exception specification.
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...