29 using namespace clang;
56 bool RelativeToPrimary,
70 dyn_cast<VarTemplateSpecializationDecl>(D)) {
73 !isa<VarTemplatePartialSpecializationDecl>(Spec))
80 assert(Spec->getSpecializedTemplate() &&
"No variable template?");
86 if (Partial->isMemberSpecialization())
89 VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
103 = dyn_cast<TemplateTemplateParmDecl>(D)) {
104 for (
unsigned I = 0, N = TTP->getDepth() + 1;
I != N; ++
I)
114 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
117 !isa<ClassTemplatePartialSpecializationDecl>(Spec))
124 assert(Spec->getSpecializedTemplate() &&
"No class template?");
125 if (Spec->getSpecializedTemplate()->isMemberSpecialization())
129 else if (
FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
130 if (!RelativeToPrimary &&
131 (Function->getTemplateSpecializationKind() ==
133 !Function->getClassScopeSpecializationPattern()))
137 = Function->getTemplateSpecializationArgs()) {
143 assert(Function->getPrimaryTemplate() &&
"No function template?");
144 if (Function->getPrimaryTemplate()->isMemberSpecialization())
152 = Function->getDescribedFunctionTemplate()) {
161 if (Function->getFriendObjectKind() &&
162 Function->getDeclContext()->isFileContext() &&
164 Ctx = Function->getLexicalDeclContext();
165 RelativeToPrimary =
false;
168 }
else if (
CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
170 QualType T = ClassTemplate->getInjectedClassNameSpecialization();
175 if (ClassTemplate->isMemberSpecialization())
181 RelativeToPrimary =
false;
189 case TemplateInstantiation:
190 case ExceptionSpecInstantiation:
191 case DefaultTemplateArgumentInstantiation:
192 case DefaultFunctionArgumentInstantiation:
193 case ExplicitTemplateArgumentSubstitution:
194 case DeducedTemplateArgumentSubstitution:
195 case PriorTemplateArgumentSubstitution:
198 case DefaultTemplateArgumentChecking:
199 case DeclaringSpecialMember:
200 case DefiningSynthesizedFunction:
204 llvm_unreachable(
"Invalid SynthesisKind!");
221 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
228 Inst.TemplateArgs = TemplateArgs.data();
229 Inst.NumTemplateArgs = TemplateArgs.size();
234 AlreadyInstantiating =
236 .insert(std::make_pair(Inst.Entity->getCanonicalDecl(), Inst.Kind))
246 PointOfInstantiation, InstantiationRange, Entity) {}
253 PointOfInstantiation, InstantiationRange, Entity) {}
263 Template, TemplateArgs) {}
272 InstantiationRange, FunctionTemplate, nullptr,
273 TemplateArgs, &DeductionInfo) {
287 PointOfInstantiation, InstantiationRange, Template, nullptr,
288 TemplateArgs, &DeductionInfo) {}
298 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
299 TemplateArgs, &DeductionInfo) {}
309 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
310 TemplateArgs, &DeductionInfo) {}
318 PointOfInstantiation, InstantiationRange, Param, nullptr,
328 PointOfInstantiation, InstantiationRange, Param, Template,
338 PointOfInstantiation, InstantiationRange, Param, Template,
347 PointOfInstantiation, InstantiationRange, Param, Template,
362 if (!Active.isInstantiationRecord()) {
372 "forgot to remove a lookup module for a template instantiation");
391 if (!AlreadyInstantiating) {
394 std::make_pair(Active.Entity, Active.Kind));
403 bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
413 SemaRef.
Diag(PointOfInstantiation,
414 diag::err_template_recursion_depth_exceeded)
416 << InstantiationRange;
417 SemaRef.
Diag(PointOfInstantiation, diag::note_template_recursion_depth)
429 SkipStart = Limit / 2 + Limit % 2;
434 unsigned InstantiationIdx = 0;
439 ++Active, ++InstantiationIdx) {
441 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
442 if (InstantiationIdx == SkipStart) {
445 diag::note_instantiation_contexts_suppressed)
451 switch (Active->Kind) {
453 Decl *D = Active->Entity;
455 unsigned DiagID = diag::note_template_member_class_here;
456 if (isa<ClassTemplateSpecializationDecl>(Record))
457 DiagID = diag::note_template_class_instantiation_here;
459 << Record << Active->InstantiationRange;
460 }
else if (
FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
462 if (Function->getPrimaryTemplate())
463 DiagID = diag::note_function_template_spec_here;
465 DiagID = diag::note_template_member_function_here;
468 << Active->InstantiationRange;
469 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
471 VD->isStaticDataMember()?
472 diag::note_template_static_data_member_def_here
473 : diag::note_template_variable_def_here)
475 << Active->InstantiationRange;
476 }
else if (
EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
478 diag::note_template_enum_def_here)
480 << Active->InstantiationRange;
481 }
else if (
FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
483 diag::note_template_nsdmi_here)
484 << FD << Active->InstantiationRange;
487 diag::note_template_type_alias_instantiation_here)
488 << cast<TypeAliasTemplateDecl>(D)
489 << Active->InstantiationRange;
495 TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
497 llvm::raw_svector_ostream OS(TemplateArgsStr);
502 diag::note_default_arg_instantiation_here)
504 << Active->InstantiationRange;
511 diag::note_explicit_template_arg_substitution_here)
514 Active->TemplateArgs,
515 Active->NumTemplateArgs)
516 << Active->InstantiationRange;
522 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
524 diag::note_function_template_deduction_instantiation_here)
527 Active->TemplateArgs,
528 Active->NumTemplateArgs)
529 << Active->InstantiationRange;
531 bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
532 isa<VarTemplateSpecializationDecl>(Active->Entity);
533 bool IsTemplate =
false;
535 if (
auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
537 Params = D->getTemplateParameters();
538 }
else if (
auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
540 Params = D->getTemplateParameters();
541 }
else if (
auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
543 Params = D->getTemplateParameters();
545 llvm_unreachable(
"unexpected template kind");
549 diag::note_deduced_template_arg_substitution_here)
550 << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
552 Active->NumTemplateArgs)
553 << Active->InstantiationRange;
559 ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
563 llvm::raw_svector_ostream OS(TemplateArgsStr);
568 diag::note_default_function_arg_instantiation_here)
570 << Active->InstantiationRange;
575 NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
578 Name = std::string(
" '") + Parm->
getName().str() +
"'";
581 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
582 TemplateParams = Template->getTemplateParameters();
585 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
586 ->getTemplateParameters();
588 diag::note_prior_template_arg_substitution)
589 << isa<TemplateTemplateParmDecl>(Parm)
592 Active->TemplateArgs,
593 Active->NumTemplateArgs)
594 << Active->InstantiationRange;
600 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
601 TemplateParams = Template->getTemplateParameters();
604 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
605 ->getTemplateParameters();
608 diag::note_template_default_arg_checking)
610 Active->TemplateArgs,
611 Active->NumTemplateArgs)
612 << Active->InstantiationRange;
618 diag::note_template_exception_spec_instantiation_here)
619 << cast<FunctionDecl>(Active->Entity)
620 << Active->InstantiationRange;
625 diag::note_in_declaration_of_implicit_special_member)
626 << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
631 auto *MD = dyn_cast<CXXMethodDecl>(Active->Entity);
635 diag::note_member_synthesized_at)
653 switch (Active->Kind) {
657 if (isa<TypeAliasTemplateDecl>(Active->Entity))
677 assert(Active->DeductionInfo &&
"Missing deduction info pointer");
678 return Active->DeductionInfo;
689 if (Active->SavedInNonInstantiationSFINAEContext)
697 static std::pair<unsigned, unsigned>
700 return std::make_pair(TTP->getDepth(), TTP->getIndex());
703 return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
713 class TemplateInstantiator :
public TreeTransform<TemplateInstantiator> {
721 TemplateInstantiator(
Sema &SemaRef,
725 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
733 bool AlreadyTransformed(
QualType T);
745 this->Entity = Entity;
751 bool &ShouldExpand,
bool &RetainExpansion,
753 return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
754 PatternRange, Unexpanded,
761 void ExpandingFunctionParameterPack(
ParmVarDecl *Pack) {
771 unsigned Depth, Index;
774 Result = TemplateArgs(Depth, Index);
790 unsigned Depth, Index;
800 void transformAttrs(
Decl *Old,
Decl *New) {
804 void transformedLocalDecl(
Decl *Old,
Decl *New) {
811 if (
auto *NewTD = NewMD->getDescribedFunctionTemplate())
812 NewTD->setInstantiatedFromMemberTemplate(
813 OldMD->getDescribedFunctionTemplate());
823 if (
auto *DC = dyn_cast<DeclContext>(Old))
859 NamedDecl *FirstQualifierInScope =
nullptr,
860 bool AllowInjectedClassName =
false);
862 const LoopHintAttr *TransformLoopHintAttr(
const LoopHintAttr *LH);
870 ExprResult TransformSubstNonTypeTemplateParmPackExpr(
888 return inherited::TransformFunctionProtoType(TLB, TL);
891 template<
typename Fn>
895 unsigned ThisTypeQuals,
896 Fn TransformExceptionSpec);
901 bool ExpectParameterPack);
921 if (!OrigTPL || !OrigTPL->
size())
return OrigTPL;
925 Owner, TemplateArgs);
926 return DeclInstantiator.SubstTemplateParams(OrigTPL);
935 bool TemplateInstantiator::AlreadyTransformed(
QualType T) {
942 getSema().MarkDeclarationsReferencedInType(Loc, T);
951 if (Arg.isPackExpansion())
972 if (TTP->isParameterPack()) {
974 "Missing argument pack");
980 "Wrong kind of template template argument");
992 Decl *Inst = getSema().SubstDecl(D, getSema().
CurContext, TemplateArgs);
996 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1001 TemplateInstantiator::TransformFirstQualifierInScope(
NamedDecl *D,
1007 = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));
1015 "Missing argument pack");
1017 if (getSema().ArgumentPackSubstitutionIndex == -1)
1025 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1028 return Tag->getDecl();
1031 getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
1036 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1040 TemplateInstantiator::RebuildExceptionDecl(
VarDecl *ExceptionDecl,
1045 VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
1046 StartLoc, NameLoc, Name);
1048 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1052 VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(
VarDecl *ExceptionDecl,
1055 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
1057 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1062 TemplateInstantiator::RebuildElaboratedType(
SourceLocation KeywordLoc,
1079 SemaRef.
Diag(TagLocation, diag::err_use_with_wrong_tag)
1094 TemplateName TemplateInstantiator::TransformTemplateName(
1097 bool AllowInjectedClassName) {
1106 TTP->getPosition()))
1113 "Missing argument pack");
1115 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1119 return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
1126 assert(!Template.
isNull() &&
"Null template template argument");
1134 Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
1141 if (getSema().ArgumentPackSubstitutionIndex == -1)
1149 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
1150 FirstQualifierInScope,
1151 AllowInjectedClassName);
1163 TemplateInstantiator::TransformTemplateParmRefExpr(
DeclRefExpr *E,
1183 "unexpected pack arguments in partial substitution");
1187 "unexpected nontype template argument kind in partial substitution");
1193 "Missing argument pack");
1195 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1214 return transformNonTypeTemplateParmRef(NTTP, E->
getLocation(), Arg);
1217 const LoopHintAttr *
1218 TemplateInstantiator::TransformLoopHintAttr(
const LoopHintAttr *LH) {
1219 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).
get();
1221 if (TransformedExpr == LH->getValue())
1225 if (getSema().CheckLoopHintExpr(TransformedExpr, LH->getLocation()))
1230 return LoopHintAttr::CreateImplicit(
1231 getSema().
Context, LH->getSemanticSpelling(), LH->getOption(),
1232 LH->getState(), TransformedExpr, LH->getRange());
1235 ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
1257 VD = cast_or_null<ValueDecl>(
1258 getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
1271 isa<PackExpansionType>(parm->
getType())) {
1273 cast<PackExpansionType>(parm->
getType())->getPattern(),
1279 assert(!type.
isNull() &&
"type substitution failed for param type");
1283 if (!result.isInvalid()) type = result.get()->getType();
1291 if (result.isInvalid())
return ExprError();
1293 Expr *resultExpr = result.get();
1295 type, resultExpr->
getValueKind(), loc, parm, resultExpr);
1299 TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
1314 TemplateInstantiator::RebuildParmVarDeclRefExpr(
ParmVarDecl *PD,
1317 return getSema().BuildDeclarationNameExpr(
CXXScopeSpec(), NameInfo, PD);
1328 return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(VD), E->
getExprLoc());
1342 cast_or_null<ParmVarDecl>(TransformDecl(E->
getExprLoc(), *
I));
1354 TemplateInstantiator::TransformFunctionParmPackRefExpr(
DeclRefExpr *E,
1357 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
1358 = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
1359 assert(Found &&
"no instantiation for parameter pack");
1361 Decl *TransformedDecl;
1362 if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
1373 TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
1375 TransformedDecl = Found->get<
Decl*>();
1379 return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(TransformedDecl),
1384 TemplateInstantiator::TransformDeclRefExpr(
DeclRefExpr *E) {
1391 return TransformTemplateParmRefExpr(E, NTTP);
1400 return TransformFunctionParmPackRefExpr(E, PD);
1405 ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
1408 getDescribedFunctionTemplate() &&
1409 "Default arg expressions are never formed in dependent cases.");
1415 template<
typename Fn>
1419 unsigned ThisTypeQuals,
1420 Fn TransformExceptionSpec) {
1423 return inherited::TransformFunctionProtoType(
1424 TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
1428 TemplateInstantiator::TransformFunctionTypeParam(
ParmVarDecl *OldParm,
1429 int indexAdjustment,
1431 bool ExpectParameterPack) {
1433 NumExpansions, ExpectParameterPack);
1437 TemplateInstantiator::TransformTemplateTypeParmType(
TypeLocBuilder &TLB,
1459 "Missing argument pack");
1461 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1466 = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
1477 "Template argument kind mismatch");
1483 = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
1496 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
1499 QualType Result = getSema().Context.getTemplateTypeParmType(
1508 TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
1523 Result = getSema().Context.getSubstTemplateTypeParmType(
1566 bool AllowDeducedTST) {
1568 "Cannot perform an instantiation without some context on the "
1569 "instantiation stack");
1575 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1576 return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(T)
1577 : Instantiator.TransformType(T);
1585 "Cannot perform an instantiation without some context on the "
1586 "instantiation stack");
1600 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1603 QualType Result = Instantiator.TransformType(TLB, TL);
1615 "Cannot perform an instantiation without some context on the "
1616 "instantiation stack");
1623 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc, Entity);
1624 return Instantiator.TransformType(T);
1658 unsigned ThisTypeQuals) {
1660 "Cannot perform an instantiation without some context on the "
1661 "instantiation stack");
1666 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1682 Result = Instantiator.TransformFunctionProtoType(
1683 TLB, Proto, ThisContext, ThisTypeQuals,
1685 bool &Changed) {
return false; });
1687 Result = Instantiator.TransformType(TLB, TL);
1701 bool Changed =
false;
1702 TemplateInstantiator Instantiator(*
this, Args, Loc,
DeclarationName());
1703 return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
1714 ESI, ExceptionStorage, Args))
1723 int indexAdjustment,
1725 bool ExpectParameterPack) {
1734 NewDI =
SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
1745 }
else if (ExpectParameterPack) {
1751 diag::err_function_parameter_pack_without_parameter_packs)
1838 "Cannot perform an instantiation without some context on the "
1839 "instantiation stack");
1841 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
1843 return Instantiator.TransformFunctionTypeParams(
1844 Loc, Params,
nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
1857 bool Invalid =
false;
1859 for (
const auto &
Base : Pattern->
bases()) {
1860 if (!
Base.getType()->isDependentType()) {
1862 if (RD->isInvalidDecl())
1871 if (
Base.isPackExpansion()) {
1877 bool ShouldExpand =
false;
1878 bool RetainExpansion =
false;
1881 Base.getSourceRange(),
1883 TemplateArgs, ShouldExpand,
1892 for (
unsigned I = 0;
I != *NumExpansions; ++
I) {
1897 Base.getSourceRange().getBegin(),
1906 Base.getSourceRange(),
1908 Base.getAccessSpecifierAsWritten(),
1911 InstantiatedBases.push_back(InstantiatedBase);
1920 EllipsisLoc =
Base.getEllipsisLoc();
1924 Base.getSourceRange().getBegin(),
1929 Base.getSourceRange().getBegin(),
1940 Base.getSourceRange(),
1942 Base.getAccessSpecifierAsWritten(),
1945 InstantiatedBases.push_back(InstantiatedBase);
1999 Pattern, PatternDef, TSK, Complain))
2001 Pattern = PatternDef;
2007 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2009 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
2010 Spec->setTemplateSpecializationKind(TSK);
2011 Spec->setPointOfInstantiation(PointOfInstantiation);
2019 "instantiating class definition");
2063 for (
auto *Member : Pattern->
decls()) {
2073 if (Member->getDeclContext() != Pattern)
2076 if (Member->isInvalidDecl()) {
2081 Decl *NewMember = Instantiator.
Visit(Member);
2083 if (
FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
2084 Fields.push_back(Field);
2085 }
else if (
EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
2091 Enum->isCompleteDefinition()) {
2093 assert(MSInfo &&
"no spec info for member enum specialization");
2098 if (SA->isFailed()) {
2130 for (LateInstantiatedAttrVec::iterator
I = LateAttrs.begin(),
2131 E = LateAttrs.end();
I !=
E; ++
I) {
2144 I->NewDecl->addAttr(NewAttr);
2172 P->first,
P->second)) {
2185 P->first,
P->second)) {
2229 Pattern, PatternDef, TSK,
true))
2231 Pattern = PatternDef;
2237 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2246 "instantiating enum definition");
2296 "pattern and instantiation disagree about init style");
2304 Diag(PointOfInstantiation,
2305 diag::err_in_class_initializer_not_yet_parsed)
2306 << OutermostClass << Pattern;
2307 Diag(Pattern->getLocEnd(), diag::note_in_class_initializer_not_yet_parsed);
2317 Diag(PointOfInstantiation, diag::err_in_class_initializer_cycle)
2322 "instantiating default member init");
2338 Expr *Init = NewInit.get();
2339 assert((!Init || !isa<ParenListExpr>(Init)) &&
"call-style init in class");
2344 L->DefaultMemberInitializerInstantiated(Instantiation);
2353 struct PartialSpecMatchResult {
2368 for (
unsigned I = 0, N = PartialSpecs.size();
I != N; ++
I) {
2401 typedef PartialSpecMatchResult MatchResult;
2406 for (
unsigned I = 0, N = PartialSpecs.size();
I != N; ++
I) {
2418 Matched.push_back(PartialSpecMatchResult());
2419 Matched.back().Partial = Partial;
2420 Matched.back().Args = Info.take();
2428 if (Matched.size() >= 1) {
2430 if (Matched.size() == 1) {
2443 PEnd = Matched.end();
2446 P->Partial, Best->Partial, PointOfInstantiation) ==
P->Partial)
2452 bool Ambiguous =
false;
2454 PEnd = Matched.end();
2458 PointOfInstantiation) !=
2469 S.
Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
2470 << ClassTemplateSpec;
2474 PEnd = Matched.end();
2476 S.
Diag(
P->Partial->getLocation(), diag::note_partial_spec_match)
2478 P->Partial->getTemplateParameters(), *
P->Args);
2495 Pattern = OrigPartialSpec;
2521 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
2527 *
this, PointOfInstantiation, ClassTemplateSpec, TSK, Complain);
2551 "Unexpected template specialization kind!");
2552 for (
auto *D : Instantiation->
decls()) {
2553 bool SuppressNew =
false;
2554 if (
auto *Function = dyn_cast<FunctionDecl>(D)) {
2556 = Function->getInstantiatedFromMemberFunction()) {
2558 = Function->getMemberSpecializationInfo();
2559 assert(MSInfo &&
"No member specialization information?");
2581 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2583 if (Function->isDefined()) {
2591 std::make_pair(Function, PointOfInstantiation));
2594 }
else if (
auto *Var = dyn_cast<VarDecl>(D)) {
2595 if (isa<VarTemplateSpecializationDecl>(Var))
2600 assert(MSInfo &&
"No member specialization information?");
2629 }
else if (
auto *Record = dyn_cast<CXXRecordDecl>(D)) {
2635 if (Record->isInjectedClassName() || Record->getPreviousDecl() ||
2640 assert(MSInfo &&
"No member specialization information?");
2663 assert(Pattern &&
"Missing instantiated-from-template information");
2665 if (!Record->getDefinition()) {
2686 Record->getTemplateSpecializationKind() ==
2688 Record->setTemplateSpecializationKind(TSK);
2693 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
2697 }
else if (
auto *Enum = dyn_cast<EnumDecl>(D)) {
2699 assert(MSInfo &&
"No member specialization information?");
2706 PointOfInstantiation, TSK, Enum,
2712 if (Enum->getDefinition())
2715 EnumDecl *Pattern = Enum->getTemplateInstantiationPattern();
2716 assert(Pattern &&
"Missing instantiated-from-template information");
2722 InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
2727 }
else if (
auto *Field = dyn_cast<FieldDecl>(D)) {
2734 ClassPattern->
lookup(Field->getDeclName());
2769 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2772 return Instantiator.TransformStmt(S);
2780 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2783 return Instantiator.TransformExpr(E);
2788 bool CXXDirectInit) {
2789 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2792 return Instantiator.TransformInitializer(Init, CXXDirectInit);
2801 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2804 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
2814 TemplateInstantiator Instantiator(*
this, TemplateArgs, NNS.
getBeginLoc(),
2816 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
2823 TemplateInstantiator Instantiator(*
this, TemplateArgs, NameInfo.
getLoc(),
2825 return Instantiator.TransformDeclarationNameInfo(NameInfo);
2832 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
2835 SS.
Adopt(QualifierLoc);
2836 return Instantiator.TransformTemplateName(SS, Name, Loc);
2842 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
2845 return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
2853 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
2854 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
2855 unsigned i = PV->getFunctionScopeIndex();
2858 if (FD->getParamDecl(i) == PV)
2866 llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
2873 const Decl *CheckD = D;
2875 LocalDeclsMap::iterator Found =
Current->LocalDecls.find(CheckD);
2876 if (Found !=
Current->LocalDecls.end())
2877 return &Found->second;
2881 if (
const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
2888 if (!
Current->CombineWithOuterScope)
2894 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
2895 isa<TemplateTemplateParmDecl>(D))
2900 if (RD->isLocalClass())
2905 if (isa<EnumDecl>(D))
2911 assert(isa<LabelDecl>(D) &&
"declaration not instantiated in this scope");
2917 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2918 if (Stored.isNull()) {
2922 while (Current->CombineWithOuterScope && Current->Outer) {
2923 Current = Current->Outer;
2924 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
2925 "Instantiated local in inner and outer scopes");
2929 }
else if (DeclArgumentPack *Pack = Stored.dyn_cast<DeclArgumentPack *>()) {
2930 Pack->push_back(cast<ParmVarDecl>(Inst));
2932 assert(Stored.get<
Decl *>() == Inst &&
"Already instantiated this local");
2939 DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
2940 Pack->push_back(Inst);
2948 assert(
Current->LocalDecls.find(D) ==
Current->LocalDecls.end() &&
2949 "Creating local pack after instantiation of local");
2953 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2954 DeclArgumentPack *Pack =
new DeclArgumentPack;
2956 ArgumentPacks.push_back(Pack);
2961 unsigned NumExplicitArgs) {
2962 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
2963 "Already have a partially-substituted pack");
2964 assert((!PartiallySubstitutedPack
2965 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
2966 "Wrong number of arguments in partially-substituted pack");
2967 PartiallySubstitutedPack = Pack;
2968 ArgsInPartiallySubstitutedPack = ExplicitArgs;
2969 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
2974 unsigned *NumExplicitArgs)
const {
2976 *ExplicitArgs =
nullptr;
2977 if (NumExplicitArgs)
2978 *NumExplicitArgs = 0;
2982 if (
Current->PartiallySubstitutedPack) {
2984 *ExplicitArgs =
Current->ArgsInPartiallySubstitutedPack;
2985 if (NumExplicitArgs)
2986 *NumExplicitArgs =
Current->NumArgsInPartiallySubstitutedPack;
2988 return Current->PartiallySubstitutedPack;
2991 if (!
Current->CombineWithOuterScope)
ExprResult BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg, SourceLocation Loc)
Construct a new expression that refers to the given integral template argument with the given source-...
Defines the clang::ASTContext interface.
void ActOnFinishDelayedMemberInitializers(Decl *Record)
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
void InstantiateClassMembers(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiates the definitions of all of the member of the given class, which is an instantiation of a ...
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
ParmVarDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
We are defining a synthesized function (such as a defaulted special member).
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier * > Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
unsigned getDepth() const
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
delayed_var_partial_spec_iterator delayed_var_partial_spec_begin()
no exception specification
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization, retrieves the member specialization information.
A (possibly-)qualified type.
TemplateDeductionResult
Describes the result of template argument deduction.
void InstantiatedLocal(const Decl *D, Decl *Inst)
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
A stack-allocated class that identifies which local variable declaration instantiations are present i...
unsigned getTemplateBacktraceLimit() const
Retrieve the maximum number of template instantiation notes to emit along with a given diagnostic...
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
void addOuterTemplateArguments(const TemplateArgumentList *TemplateArgs)
Add a new outermost level to the multi-level template argument list.
const LangOptions & getLangOpts() const
Decl * Entity
The entity that is being synthesized.
bool isMemberSpecialization()
Determines whether this class template partial specialization template was a specialization of a memb...
Stmt - This represents one statement.
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
ExprResult SubstInitializer(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs, bool CXXDirectInit)
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
Provides information about an attempted template argument deduction, whose success or failure was des...
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed...
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...
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
The template argument is an expression, and we've not resolved it to one of the other forms yet...
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments...
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
bool hasTemplateArgument(unsigned Depth, unsigned Index) const
Determine whether there is a non-NULL template argument at the given depth and index.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Decl - This represents one declaration (or definition), e.g.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
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.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization...
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
SmallVector< Module *, 16 > CodeSynthesisContextLookupModules
Extra modules inspected when performing a lookup during a template instantiation. ...
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Declaration of a variable template.
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
static void PrintTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, bool SkipBrackets=false)
Print a template argument list, including the '<' and '>' enclosing the template arguments...
NamedDecl * getParam(unsigned Idx)
A container of type source information.
unsigned getIndex() const
Expr * getAsExpr() const
Retrieve the template argument as an expression.
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.
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.
Expr * getInClassInitializer() const
getInClassInitializer - Get the C++11 in-class initializer for this member, or null if one has not be...
InClassInitStyle getInClassInitStyle() const
getInClassInitStyle - Get the kind of (C++11) in-class initializer which this field has...
IdentType getIdentType() const
void ActOnFinishCXXNonNestedClass(Decl *D)
This file provides some common utility functions for processing Lambda related AST Constructs...
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
void InstantiatedLocalPackArg(const Decl *D, ParmVarDecl *Inst)
RAII object that enters a new expression evaluation context.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Information about one declarator, including the parsed type information and the identifier.
DiagnosticsEngine & Diags
TypeSourceInfo * SubstFunctionDeclType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext, unsigned ThisTypeQuals)
A form of SubstType intended specifically for instantiating the type of a FunctionDecl.
Represents a variable template specialization, which refers to a variable template with a given set o...
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
TemplateTypeParmDecl * getDecl() const
SmallVectorImpl< std::pair< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > >::iterator delayed_partial_spec_iterator
Stores a list of template parameters for a TemplateDecl and its derived classes.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
const ParmVarDecl * getParam() const
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
ParmVarDecl - Represents a parameter to a function.
unsigned getNumArgs() const
Retrieve the number of template arguments.
SourceLocation getLocation() const
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
Base wrapper for a particular "section" of type source info.
RecordDecl - Represents a struct/union/class.
bool isAlreadyInstantiating() const
Determine whether we are already instantiating this specialization in some surrounding active instant...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
bool hasUninstantiatedDefaultArg() const
void PrintInstantiationStack()
Prints the current instantiation stack through a series of notes.
DeclarationName getName() const
getName - Returns the embedded declaration name.
One of these records is kept for each identifier that is lexed.
Represents a class template specialization, which refers to a class template with a given set of temp...
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
void setUninstantiatedDefaultArg(Expr *arg)
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
A C++ nested-name-specifier augmented with source location information.
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
The results of name lookup within a DeclContext.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
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.
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)
CXXRecordDecl * getDefinition() const
bool isTranslationUnit() const
Interesting information about a specific parameter that can't simply be reflected in parameter's type...
TagKind getTagKind() const
bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, Optional< unsigned > &NumExpansions)
Determine whether we could expand a pack expansion with the given set of parameter packs into separat...
DeclarationNameInfo SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, const MultiLevelTemplateArgumentList &TemplateArgs)
Do template substitution on declaration name info.
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()
Describes a module or submodule.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
We are instantiating the exception specification for a function template which was deferred until it ...
TemplateArgument getArgumentPack() const
void setNameLoc(SourceLocation Loc)
const TargetInfo & getTargetInfo() const
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For an enumeration member that was instantiated from a member enumeration of a templated class...
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
A convenient class for passing around template argument information.
static TemplateArgument getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg)
StmtResult SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs)
virtual void printName(raw_ostream &os) const
Wrapper for substituted template type parameters.
llvm::DenseSet< Module * > LookupModulesCache
Cache of additional modules that should be used for name lookup within the current template instantia...
ParmVarDecl * getExpansion(unsigned I) const
Get an expansion of the parameter pack by index.
Wrapper for substituted template type parameters.
unsigned LastEmittedCodeSynthesisContextDepth
The depth of the context stack at the point when the most recent error or warning was produced...
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
bool isInstantiationRecord() const
Determines whether this template is an actual instantiation that should be counted toward the maximum...
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.
CXXBaseSpecifier * CheckBaseSpecifier(CXXRecordDecl *Class, SourceRange SpecifierRange, bool Virtual, AccessSpecifier Access, TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)
ActOnBaseSpecifier - Parsed a base specifier.
Represents a C++ nested-name-specifier or a global scope specifier.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
bool isLambdaCallOperator(const CXXMethodDecl *MD)
SourceLocation getLocation() const
detail::InMemoryDirectory::const_iterator I
SourceLocation getUsedLocation() const
Retrieve the location where this default argument was actually used.
A default argument (C++ [dcl.fct.default]).
void setLocStart(SourceLocation L)
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
RAII object used to change the argument pack substitution index within a Sema object.
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
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.
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
bool SubstBaseSpecifiers(CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Perform substitution on the base class specifiers of the given class template specialization.
void MakeInstantiatedLocalArgPack(const Decl *D)
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.
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
bool InstantiateEnum(SourceLocation PointOfInstantiation, EnumDecl *Instantiation, EnumDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiate the definition of an enum from a given pattern.
bool isParameterPack() const
Determine whether this parameter is actually a function parameter pack.
unsigned getNumExpansions() const
Get the number of parameters in this parameter pack.
bool CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind NewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPtOfInstantiation, bool &SuppressNew)
Diagnose cases where we have an explicit template specialization before/after an explicit template in...
SourceLocation getInnerLocStart() const
getInnerLocStart - Return SourceLocation representing start of source range ignoring outer template d...
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization, retrieves the member specialization information.
We are instantiating a template declaration.
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
bool InstantiateInClassInitializer(SourceLocation PointOfInstantiation, FieldDecl *Instantiation, FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the definition of a field from the given pattern.
delayed_partial_spec_iterator delayed_partial_spec_begin()
Return an iterator to the beginning of the set of "delayed" partial specializations, which must be passed to InstantiateClassTemplatePartialSpecialization once the class definition has been completed.
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, Optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(NamedDecl *D, const TemplateArgumentList *Innermost=nullptr, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Expr - This represents one expression.
Defines the clang::LangOptions interface.
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
bool hasFatalErrorOccurred() const
void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
Declaration of a template type parameter.
ClassTemplatePartialSpecializationDecl * InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl *ClassTemplate, ClassTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a class template partial specialization.
void PerformDependentDiagnostics(const DeclContext *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
This file defines the classes used to store parsed information about declaration-specifiers and decla...
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...
ExprResult BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc)
Given a non-type template argument that refers to a declaration and the type of its corresponding non...
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
TranslationUnitDecl * getTranslationUnitDecl() const
bool InNonInstantiationSFINAEContext
Whether we are in a SFINAE context that is not associated with template instantiation.
SourceLocation getLocation() const
ArgKind getKind() const
Return the kind of stored template argument.
ExtProtoInfo getExtProtoInfo() const
ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, Optional< unsigned > NumExpansions, bool ExpectParameterPack)
DeclContext * getDeclContext()
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, Expr *Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member, and after instantiating an in-class initializer in a class template.
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
ASTMutationListener * getASTMutationListener() const
QualType getType() const
Get the type for which this source info wrapper provides information.
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
void CheckCompletedCXXClass(CXXRecordDecl *Record)
Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...
unsigned getNumSubstitutedLevels() const
Determine the number of substituted levels in this template argument list.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations()
Retrieve the set of partial specializations of this class template.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Data structure that captures multiple levels of template argument lists for use in template instantia...
void setLocation(SourceLocation L)
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
Represents a reference to a non-type template parameter that has been substituted with a template arg...
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
SourceLocation getLocEnd() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
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...
SourceLocation getParameterPackLocation() const
Retrieve the location of the parameter pack name.
const TypeClass * getTypePtr() const
Attr * instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
static void deleteScopes(LocalInstantiationScope *Scope, LocalInstantiationScope *Outermost)
deletes the given scope, and all otuer scopes, down to the given outermost scope. ...
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
We are declaring an implicit special member function.
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
ExceptionSpecificationType Type
The kind of exception specification this is.
A stack object to be created when performing template instantiation.
Attr * instantiateTemplateAttributeForDecl(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, TemplateArgumentListInfo &Result, const MultiLevelTemplateArgumentList &TemplateArgs)
unsigned getNumLevels() const
Determine the number of levels in this template argument list.
Encodes a location in the source.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
void setBraceRange(SourceRange R)
sema::TemplateDeductionInfo * DeductionInfo
The template deduction info object associated with the substitution or checking of explicit or deduce...
QualType getExpansionType(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
A structure for storing an already-substituted template template parameter pack.
SourceRange getBraceRange() const
void InstantiateStaticDataMemberDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false)
Instantiate the definition of the given variable from its template.
SmallVectorImpl< std::pair< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > >::iterator delayed_var_partial_spec_iterator
TagDecl - Represents the declaration of a struct/union/class/enum.
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
SynthesisKind
The kind of template instantiation we are performing.
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
Represents a static or instance method of a struct/union/class.
SourceLocation getNameLoc() const
We are checking the validity of a default template argument that has been used when naming a template...
void reserve(size_t Requested)
Ensures that this buffer has at least as much capacity as described.
static const Decl * getCanonicalParmVarDecl(const Decl *D)
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, sema::TemplateDeductionInfo &Info)
Perform template argument deduction to determine whether the given template arguments match the given...
void setTagKind(TagKind TK)
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
ParmVarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
llvm::DenseSet< std::pair< Decl *, unsigned > > InstantiatingSpecializations
Specializations whose definitions are currently being instantiated.
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
This template specialization was instantiated from a template due to an explicit instantiation defini...
bool isFileContext() const
Represents a C++11 static_assert declaration.
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization, returns the templated static data member from which it was instantiated.
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema's representation of template deduction information to the form used in overload-can...
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, AttributeList *AttrList)
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
void setHasInheritedDefaultArg(bool I=true)
QualType getType() const
Return the type wrapped by this type source info.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
getSpecialMember - get the special member enum for a method.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
void InstantiateClassTemplateSpecializationMembers(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK)
Instantiate the definitions of all of the members of the given class template specialization, which was named as part of an explicit instantiation.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template...
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
Represents a reference to a function parameter pack that has been substituted but not yet expanded...
Represents a template argument.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
QualType getAsType() const
Retrieve the type for a type template argument.
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument. ...
Represents a template name that was expressed as a qualified name.
TagTypeKind
The kind of a tag type.
llvm::PointerUnion3< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
[C99 6.4.2.2] - A predefined identifier such as func.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
LocalInstantiationScope * getStartingScope() const
The base class of all kinds of template declarations (e.g., class, function, etc.).
bool hasUnparsedDefaultArg() const
hasUnparsedDefaultArg - Determines whether this parameter has a default argument that has not yet bee...
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
We are instantiating a default argument for a function.
bool isInvalidDecl() const
delayed_partial_spec_iterator delayed_partial_spec_end()
Return an iterator to the end of the set of "delayed" partial specializations, which must be passed t...
TypeLoc IgnoreParens() const
This template specialization was instantiated from a template due to an explicit instantiation declar...
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
bool isParameterPack() const
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
DeclarationName - The name of a declaration.
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
void setInstantiationOfMemberFunction(FunctionDecl *FD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member function FD.
SourceRange InstantiationRange
The source range that covers the construct that cause the instantiation, e.g., the template-id that c...
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool isNull() const
Determine whether this template argument has no value.
bool isDefinedOutsideFunctionOrMethod() const
isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...
EnumDecl - Represents an enum.
unsigned getFunctionScopeDepth() const
detail::InMemoryDirectory::const_iterator E
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
SourceLocation getParameterPackLocation() const
Get the location of the parameter pack.
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
unsigned getDepth() const
Get the nesting depth of the template parameter.
bool hasInheritedDefaultArg() const
const TemplateArgument * getArgs() const
Retrieve the template arguments.
Location wrapper for a TemplateArgument.
void setUnparsedDefaultArg()
setUnparsedDefaultArg - Specify that this parameter has an unparsed default argument.
Expr * getUninstantiatedDefaultArg()
const T * getAs() const
Member-template getAs<specific type>'.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
This template specialization was declared or defined by an explicit specialization (C++ [temp...
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
static std::pair< unsigned, unsigned > getDepthAndIndex(NamedDecl *ND)
Retrieve the depth and index of a parameter pack.
QualType getIntegralType() const
Retrieve the type of the integral value.
bool isNull() const
Determine whether this template name is NULL.
UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations
A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...
The template argument is a type.
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
The template argument is actually a parameter pack.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
bool isStaticDataMember() const
Determines whether this is a static data member.
Represents a base class of a C++ class.
bool isLexicallyWithinFunctionOrMethod() const
Returns true if this declaration lexically is inside a function.
bool SavedInNonInstantiationSFINAEContext
Was the enclosing context a non-instantiation SFINAE context?
static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, ParmVarDecl *ParamPack, SourceLocation NameLoc, ArrayRef< ParmVarDecl * > Params)
A template argument list.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
unsigned getFullDataSize() const
Returns the size of the type source info data block.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Represents a C++ struct/union/class.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T)
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
void enableLateAttributeInstantiation(Sema::LateInstantiatedAttrVec *LA)
bool SubstExprs(ArrayRef< Expr * > Exprs, bool IsCall, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< Expr * > &Outputs)
Substitute the given template arguments into a list of expressions, expanding pack expansions if requ...
void 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...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Declaration of a class template.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
QualType getParamTypeForDecl() const
We are substituting prior template arguments into a new template parameter.
ArrayRef< ParmVarDecl * > getParams() const
ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)
Returns the more specialized class template partial specialization according to the rules of partial ...
A reference to a declared variable, function, enum, etc.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Represents a type template specialization; the template must be a class template, a type alias templa...
SourceLocation getInnerLocStart() const
getInnerLocStart - Return SourceLocation representing start of source range ignoring outer template d...
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
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.
StringRef getKindName() const
Wrapper for template type parameters.
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
NamedDecl - This represents a decl with a name.
NamedDecl * getAsNamedDecl(TemplateParameter P)
EnumDecl * getDefinition() const
No keyword precedes the qualified type name.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
bool hasUncompilableErrorOccurred() const
Errors that actually prevent compilation, not those that are upgraded from a warning by -Werror...
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
SourceLocation getLocStart() const LLVM_READONLY
ExceptionSpecInfo ExceptionSpec
Declaration of a template function.
Attr - This represents one attribute.
std::vector< const ClassTemplatePartialSpecializationDecl * > PartialSpecs
const RecordDecl * getParent() const
getParent - Returns the parent of this field declaration, which is the struct in which this field is ...
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
virtual void HandleTagDeclDefinition(TagDecl *D)
HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.
bool hasInClassInitializer() const
hasInClassInitializer - Determine whether this member has a C++11 in-class initializer.
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...