28 #include "llvm/Support/TimeProfiler.h" 30 using namespace clang;
57 bool RelativeToPrimary,
77 !isa<VarTemplatePartialSpecializationDecl>(Spec))
90 if (Partial->isMemberSpecialization())
93 VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
107 = dyn_cast<TemplateTemplateParmDecl>(D)) {
108 for (
unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I)
122 !isa<ClassTemplatePartialSpecializationDecl>(Spec))
134 else if (
FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
135 if (!RelativeToPrimary &&
136 Function->getTemplateSpecializationKindForInstantiation() ==
141 = Function->getTemplateSpecializationArgs()) {
147 assert(Function->getPrimaryTemplate() &&
"No function template?");
148 if (Function->getPrimaryTemplate()->isMemberSpecialization())
156 = Function->getDescribedFunctionTemplate()) {
165 if (Function->getFriendObjectKind() &&
166 Function->getDeclContext()->isFileContext() &&
168 Ctx = Function->getLexicalDeclContext();
169 RelativeToPrimary =
false;
172 }
else if (
CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
174 QualType T = ClassTemplate->getInjectedClassNameSpecialization();
179 if (ClassTemplate->isMemberSpecialization())
185 RelativeToPrimary =
false;
193 case TemplateInstantiation:
194 case ExceptionSpecInstantiation:
195 case DefaultTemplateArgumentInstantiation:
196 case DefaultFunctionArgumentInstantiation:
197 case ExplicitTemplateArgumentSubstitution:
198 case DeducedTemplateArgumentSubstitution:
199 case PriorTemplateArgumentSubstitution:
202 case DefaultTemplateArgumentChecking:
203 case DeclaringSpecialMember:
204 case DefiningSynthesizedFunction:
205 case ExceptionSpecEvaluation:
213 llvm_unreachable(
"Invalid SynthesisKind!");
230 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
243 AlreadyInstantiating =
256 PointOfInstantiation, InstantiationRange, Entity) {}
263 PointOfInstantiation, InstantiationRange, Entity) {}
273 Template, TemplateArgs) {}
282 InstantiationRange, FunctionTemplate, nullptr,
283 TemplateArgs, &DeductionInfo) {
297 PointOfInstantiation, InstantiationRange, Template, nullptr,
298 TemplateArgs, &DeductionInfo) {}
308 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
309 TemplateArgs, &DeductionInfo) {}
319 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
320 TemplateArgs, &DeductionInfo) {}
328 PointOfInstantiation, InstantiationRange, Param, nullptr,
338 PointOfInstantiation, InstantiationRange, Param, Template,
348 PointOfInstantiation, InstantiationRange, Param, Template,
357 PointOfInstantiation, InstantiationRange, Param, Template,
372 if (!Active.isInstantiationRecord()) {
382 "forgot to remove a lookup module for a template instantiation");
401 if (!AlreadyInstantiating) {
404 std::make_pair(Active.Entity, Active.Kind));
415 bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
425 SemaRef.
Diag(PointOfInstantiation,
426 diag::err_template_recursion_depth_exceeded)
428 << InstantiationRange;
429 SemaRef.
Diag(PointOfInstantiation, diag::note_template_recursion_depth)
441 SkipStart = Limit / 2 + Limit % 2;
446 unsigned InstantiationIdx = 0;
451 ++Active, ++InstantiationIdx) {
453 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
454 if (InstantiationIdx == SkipStart) {
457 diag::note_instantiation_contexts_suppressed)
463 switch (Active->Kind) {
465 Decl *D = Active->Entity;
467 unsigned DiagID = diag::note_template_member_class_here;
468 if (isa<ClassTemplateSpecializationDecl>(Record))
469 DiagID = diag::note_template_class_instantiation_here;
471 << Record << Active->InstantiationRange;
472 }
else if (
FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
474 if (Function->getPrimaryTemplate())
475 DiagID = diag::note_function_template_spec_here;
477 DiagID = diag::note_template_member_function_here;
480 << Active->InstantiationRange;
481 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
483 VD->isStaticDataMember()?
484 diag::note_template_static_data_member_def_here
485 : diag::note_template_variable_def_here)
487 << Active->InstantiationRange;
488 }
else if (
EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
490 diag::note_template_enum_def_here)
492 << Active->InstantiationRange;
493 }
else if (
FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
495 diag::note_template_nsdmi_here)
496 << FD << Active->InstantiationRange;
499 diag::note_template_type_alias_instantiation_here)
500 << cast<TypeAliasTemplateDecl>(D)
501 << Active->InstantiationRange;
507 TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
509 llvm::raw_svector_ostream OS(TemplateArgsStr);
514 diag::note_default_arg_instantiation_here)
516 << Active->InstantiationRange;
523 diag::note_explicit_template_arg_substitution_here)
526 Active->TemplateArgs,
527 Active->NumTemplateArgs)
528 << Active->InstantiationRange;
534 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
536 diag::note_function_template_deduction_instantiation_here)
539 Active->TemplateArgs,
540 Active->NumTemplateArgs)
541 << Active->InstantiationRange;
543 bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
544 isa<VarTemplateSpecializationDecl>(Active->Entity);
545 bool IsTemplate =
false;
547 if (
auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
549 Params = D->getTemplateParameters();
550 }
else if (
auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
552 Params = D->getTemplateParameters();
553 }
else if (
auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
555 Params = D->getTemplateParameters();
557 llvm_unreachable(
"unexpected template kind");
561 diag::note_deduced_template_arg_substitution_here)
562 << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
564 Active->NumTemplateArgs)
565 << Active->InstantiationRange;
571 ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
575 llvm::raw_svector_ostream OS(TemplateArgsStr);
580 diag::note_default_function_arg_instantiation_here)
582 << Active->InstantiationRange;
587 NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
590 Name = std::string(
" '") + Parm->
getName().str() +
"'";
593 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
594 TemplateParams = Template->getTemplateParameters();
597 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
598 ->getTemplateParameters();
600 diag::note_prior_template_arg_substitution)
601 << isa<TemplateTemplateParmDecl>(Parm)
604 Active->TemplateArgs,
605 Active->NumTemplateArgs)
606 << Active->InstantiationRange;
612 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
613 TemplateParams = Template->getTemplateParameters();
616 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
617 ->getTemplateParameters();
620 diag::note_template_default_arg_checking)
622 Active->TemplateArgs,
623 Active->NumTemplateArgs)
624 << Active->InstantiationRange;
630 diag::note_evaluating_exception_spec_here)
631 << cast<FunctionDecl>(Active->Entity);
636 diag::note_template_exception_spec_instantiation_here)
637 << cast<FunctionDecl>(Active->Entity)
638 << Active->InstantiationRange;
643 diag::note_in_declaration_of_implicit_special_member)
644 << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
649 auto *MD = dyn_cast<CXXMethodDecl>(Active->Entity);
653 diag::note_member_synthesized_at)
675 switch (Active->Kind) {
679 if (isa<TypeAliasTemplateDecl>(Active->Entity))
699 assert(Active->DeductionInfo &&
"Missing deduction info pointer");
700 return Active->DeductionInfo;
720 if (Active->SavedInNonInstantiationSFINAEContext)
731 class TemplateInstantiator :
public TreeTransform<TemplateInstantiator> {
739 TemplateInstantiator(
Sema &SemaRef,
743 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
751 bool AlreadyTransformed(
QualType T);
763 this->Entity = Entity;
769 bool &ShouldExpand,
bool &RetainExpansion,
771 return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
772 PatternRange, Unexpanded,
779 void ExpandingFunctionParameterPack(
ParmVarDecl *Pack) {
789 unsigned Depth, Index;
792 Result = TemplateArgs(Depth, Index);
808 unsigned Depth, Index;
818 void transformAttrs(
Decl *Old,
Decl *New) {
825 for (
auto *New : NewDecls)
827 Old, cast<VarDecl>(New));
831 assert(NewDecls.size() == 1 &&
832 "should only have multiple expansions for a pack");
833 Decl *New = NewDecls.front();
841 if (
auto *NewTD = NewMD->getDescribedFunctionTemplate())
842 NewTD->setInstantiatedFromMemberTemplate(
843 OldMD->getDescribedFunctionTemplate());
853 if (
auto *DC = dyn_cast<DeclContext>(Old))
889 NamedDecl *FirstQualifierInScope =
nullptr,
890 bool AllowInjectedClassName =
false);
892 const LoopHintAttr *TransformLoopHintAttr(
const LoopHintAttr *LH);
900 ExprResult TransformSubstNonTypeTemplateParmPackExpr(
917 return inherited::TransformFunctionProtoType(TLB, TL);
920 template<
typename Fn>
925 Fn TransformExceptionSpec);
930 bool ExpectParameterPack);
950 if (!OrigTPL || !OrigTPL->
size())
return OrigTPL;
954 Owner, TemplateArgs);
964 bool TemplateInstantiator::AlreadyTransformed(
QualType T) {
971 getSema().MarkDeclarationsReferencedInType(Loc, T);
980 if (Arg.isPackExpansion())
990 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
995 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
1001 if (TTP->isParameterPack()) {
1003 "Missing argument pack");
1009 "Wrong kind of template template argument");
1021 Decl *Inst = getSema().SubstDecl(D, getSema().
CurContext, TemplateArgs);
1025 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1030 TemplateInstantiator::TransformFirstQualifierInScope(
NamedDecl *D,
1036 = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));
1038 if (TTP->
getDepth() < TemplateArgs.getNumLevels()) {
1044 "Missing argument pack");
1046 if (getSema().ArgumentPackSubstitutionIndex == -1)
1054 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1057 return Tag->getDecl();
1060 getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
1065 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1069 TemplateInstantiator::RebuildExceptionDecl(
VarDecl *ExceptionDecl,
1074 VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
1075 StartLoc, NameLoc, Name);
1077 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1081 VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(
VarDecl *ExceptionDecl,
1084 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
1086 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1091 TemplateInstantiator::RebuildElaboratedType(
SourceLocation KeywordLoc,
1108 SemaRef.
Diag(TagLocation, diag::err_use_with_wrong_tag)
1123 TemplateName TemplateInstantiator::TransformTemplateName(
1126 bool AllowInjectedClassName) {
1129 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
1134 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
1135 TTP->getPosition()))
1140 if (TTP->isParameterPack()) {
1142 "Missing argument pack");
1144 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1148 return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
1155 assert(!Template.
isNull() &&
"Null template template argument");
1157 "template decl to substitute is qualified?");
1159 Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
1166 if (getSema().ArgumentPackSubstitutionIndex == -1)
1174 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
1175 FirstQualifierInScope,
1176 AllowInjectedClassName);
1180 TemplateInstantiator::TransformPredefinedExpr(
PredefinedExpr *E) {
1188 TemplateInstantiator::TransformTemplateParmRefExpr(
DeclRefExpr *E,
1194 if (!TemplateArgs.hasTemplateArgument(NTTP->
getDepth(),
1200 if (TemplateArgs.getNumLevels() != TemplateArgs.getNumSubstitutedLevels()) {
1208 "unexpected pack arguments in partial substitution");
1212 "unexpected nontype template argument kind in partial substitution");
1218 "Missing argument pack");
1220 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1239 return transformNonTypeTemplateParmRef(NTTP, E->
getLocation(), Arg);
1242 const LoopHintAttr *
1243 TemplateInstantiator::TransformLoopHintAttr(
const LoopHintAttr *LH) {
1244 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).
get();
1246 if (TransformedExpr == LH->getValue())
1250 if (getSema().CheckLoopHintExpr(TransformedExpr, LH->getLocation()))
1255 return LoopHintAttr::CreateImplicit(
1256 getSema().
Context, LH->getSemanticSpelling(), LH->getOption(),
1257 LH->getState(), TransformedExpr, LH->getRange());
1260 ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
1282 VD = cast_or_null<ValueDecl>(
1283 getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
1296 isa<PackExpansionType>(parm->
getType())) {
1298 cast<PackExpansionType>(parm->
getType())->getPattern(),
1304 assert(!type.
isNull() &&
"type substitution failed for param type");
1308 if (!result.isInvalid()) type = result.get()->getType();
1318 Expr *resultExpr = result.
get();
1320 type, resultExpr->
getValueKind(), loc, parm, resultExpr);
1324 TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
1341 return getSema().BuildDeclarationNameExpr(
CXXScopeSpec(), NameInfo, PD);
1352 return RebuildVarDeclRefExpr(VD, E->
getExprLoc());
1374 getSema().MarkFunctionParmPackReferenced(PackExpr);
1379 TemplateInstantiator::TransformFunctionParmPackRefExpr(
DeclRefExpr *E,
1382 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
1383 = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
1384 assert(Found &&
"no instantiation for parameter pack");
1386 Decl *TransformedDecl;
1387 if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
1396 getSema().MarkFunctionParmPackReferenced(PackExpr);
1400 TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
1402 TransformedDecl = Found->get<
Decl*>();
1406 return RebuildVarDeclRefExpr(cast<VarDecl>(TransformedDecl), E->
getExprLoc());
1410 TemplateInstantiator::TransformDeclRefExpr(
DeclRefExpr *E) {
1416 if (NTTP->
getDepth() < TemplateArgs.getNumLevels())
1417 return TransformTemplateParmRefExpr(E, NTTP);
1424 if (
VarDecl *PD = dyn_cast<VarDecl>(D))
1426 return TransformFunctionParmPackRefExpr(E, PD);
1431 ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
1434 getDescribedFunctionTemplate() &&
1435 "Default arg expressions are never formed in dependent cases.");
1441 template<
typename Fn>
1446 Fn TransformExceptionSpec) {
1449 return inherited::TransformFunctionProtoType(
1450 TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
1454 TemplateInstantiator::TransformFunctionTypeParam(
ParmVarDecl *OldParm,
1455 int indexAdjustment,
1457 bool ExpectParameterPack) {
1459 NumExpansions, ExpectParameterPack);
1463 TemplateInstantiator::TransformTemplateTypeParmType(
TypeLocBuilder &TLB,
1466 if (T->
getDepth() < TemplateArgs.getNumLevels()) {
1485 "Missing argument pack");
1487 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1492 = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
1503 "Template argument kind mismatch");
1509 = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
1522 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
1534 TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
1549 Result = getSema().Context.getSubstTemplateTypeParmType(
1592 bool AllowDeducedTST) {
1594 "Cannot perform an instantiation without some context on the " 1595 "instantiation stack");
1601 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1602 return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(T)
1603 : Instantiator.TransformType(T);
1611 "Cannot perform an instantiation without some context on the " 1612 "instantiation stack");
1626 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1641 "Cannot perform an instantiation without some context on the " 1642 "instantiation stack");
1649 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc, Entity);
1650 return Instantiator.TransformType(T);
1686 "Cannot perform an instantiation without some context on the " 1687 "instantiation stack");
1692 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
1708 Result = Instantiator.TransformFunctionProtoType(
1709 TLB, Proto, ThisContext, ThisTypeQuals,
1711 bool &Changed) {
return false; });
1713 Result = Instantiator.TransformType(TLB, TL);
1727 bool Changed =
false;
1728 TemplateInstantiator Instantiator(*
this, Args, Loc,
DeclarationName());
1729 return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
1740 ESI, ExceptionStorage, Args))
1749 int indexAdjustment,
1751 bool ExpectParameterPack) {
1760 NewDI =
SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
1771 }
else if (ExpectParameterPack) {
1777 diag::err_function_parameter_pack_without_parameter_packs)
1864 "Cannot perform an instantiation without some context on the " 1865 "instantiation stack");
1867 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
1869 return Instantiator.TransformFunctionTypeParams(
1870 Loc, Params,
nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
1883 bool Invalid =
false;
1885 for (
const auto &
Base : Pattern->
bases()) {
1886 if (!
Base.getType()->isDependentType()) {
1888 if (RD->isInvalidDecl())
1897 if (
Base.isPackExpansion()) {
1903 bool ShouldExpand =
false;
1904 bool RetainExpansion =
false;
1907 Base.getSourceRange(),
1909 TemplateArgs, ShouldExpand,
1918 for (
unsigned I = 0; I != *NumExpansions; ++I) {
1923 Base.getSourceRange().getBegin(),
1932 Base.getSourceRange(),
1934 Base.getAccessSpecifierAsWritten(),
1937 InstantiatedBases.push_back(InstantiatedBase);
1946 EllipsisLoc =
Base.getEllipsisLoc();
1950 Base.getSourceRange().getBegin(),
1955 Base.getSourceRange().getBegin(),
1966 Base.getSourceRange(),
1968 Base.getAccessSpecifierAsWritten(),
1971 InstantiatedBases.push_back(InstantiatedBase);
2025 Pattern, PatternDef, TSK, Complain))
2028 llvm::TimeTraceScope TimeScope(
"InstantiateClass", [&]() {
2030 llvm::raw_string_ostream OS(Name);
2036 Pattern = PatternDef;
2042 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2044 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
2045 Spec->setTemplateSpecializationKind(TSK);
2046 Spec->setPointOfInstantiation(PointOfInstantiation);
2054 "instantiating class definition");
2072 SavePendingParsedClassStateRAII SavedPendingParsedClassState(*
this);
2085 Instantiation->
setTagKind(Pattern->getTagKind());
2097 bool MightHaveConstexprVirtualFunctions =
false;
2098 for (
auto *Member : Pattern->decls()) {
2108 if (Member->getDeclContext() != Pattern)
2113 if (isa<BlockDecl>(Member))
2116 if (Member->isInvalidDecl()) {
2121 Decl *NewMember = Instantiator.
Visit(Member);
2123 if (
FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
2124 Fields.push_back(Field);
2125 }
else if (
EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
2131 Enum->isCompleteDefinition()) {
2133 assert(MSInfo &&
"no spec info for member enum specialization");
2138 if (SA->isFailed()) {
2144 }
else if (
CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewMember)) {
2145 if (MD->isConstexpr() && !MD->getFriendObjectKind() &&
2146 (MD->isVirtualAsWritten() || Instantiation->
getNumBases()))
2147 MightHaveConstexprVirtualFunctions =
true;
2171 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
2172 E = LateAttrs.end(); I != E; ++I) {
2185 I->NewDecl->addAttr(NewAttr);
2197 Instantiation->
setLocation(Pattern->getLocation());
2198 Instantiation->
setLocStart(Pattern->getInnerLocStart());
2213 P->first,
P->second)) {
2226 P->first,
P->second)) {
2245 else if (MightHaveConstexprVirtualFunctions)
2275 Pattern, PatternDef, TSK,
true))
2277 Pattern = PatternDef;
2283 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2292 "instantiating enum definition");
2342 "pattern and instantiation disagree about init style");
2350 Diag(PointOfInstantiation,
2351 diag::err_in_class_initializer_not_yet_parsed)
2352 << OutermostClass << Pattern;
2353 Diag(Pattern->getEndLoc(), diag::note_in_class_initializer_not_yet_parsed);
2363 Diag(PointOfInstantiation, diag::err_in_class_initializer_cycle)
2368 "instantiating default member init");
2384 Expr *Init = NewInit.get();
2385 assert((!Init || !isa<ParenListExpr>(Init)) &&
"call-style init in class");
2390 L->DefaultMemberInitializerInstantiated(Instantiation);
2399 struct PartialSpecMatchResult {
2414 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2456 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2468 Matched.push_back(PartialSpecMatchResult());
2469 Matched.back().Partial = Partial;
2470 Matched.back().Args = Info.take();
2478 if (Matched.size() >= 1) {
2480 if (Matched.size() == 1) {
2493 PEnd = Matched.end();
2496 P->Partial, Best->Partial, PointOfInstantiation) ==
2503 bool Ambiguous =
false;
2505 PEnd = Matched.end();
2508 P->Partial, Best->Partial,
2509 PointOfInstantiation) != Best->Partial) {
2519 S.
Diag(PointOfInstantiation,
2520 diag::err_partial_spec_ordering_ambiguous)
2521 << ClassTemplateSpec;
2525 PEnd = Matched.end();
2527 S.
Diag(
P->Partial->getLocation(), diag::note_partial_spec_match)
2529 P->Partial->getTemplateParameters(), *
P->Args);
2544 if (
auto *PartialSpec =
2547 while (PartialSpec->getInstantiatedFromMember()) {
2550 if (PartialSpec->isMemberSpecialization())
2553 PartialSpec = PartialSpec->getInstantiatedFromMember();
2555 Pattern = PartialSpec;
2577 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
2583 *
this, PointOfInstantiation, ClassTemplateSpec, TSK, Complain);
2607 "Unexpected template specialization kind!");
2608 for (
auto *D : Instantiation->
decls()) {
2609 bool SuppressNew =
false;
2610 if (
auto *Function = dyn_cast<FunctionDecl>(D)) {
2612 Function->getInstantiatedFromMemberFunction()) {
2614 if (Function->hasAttr<ExcludeFromExplicitInstantiationAttr>())
2618 Function->getMemberSpecializationInfo();
2619 assert(MSInfo &&
"No member specialization information?");
2641 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2643 if (Function->isDefined()) {
2651 std::make_pair(Function, PointOfInstantiation));
2654 }
else if (
auto *Var = dyn_cast<VarDecl>(D)) {
2655 if (isa<VarTemplateSpecializationDecl>(Var))
2658 if (Var->isStaticDataMember()) {
2659 if (Var->hasAttr<ExcludeFromExplicitInstantiationAttr>())
2663 assert(MSInfo &&
"No member specialization information?");
2683 if (!Var->getInstantiatedFromStaticDataMember()->getDefinition())
2686 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2689 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2692 }
else if (
auto *Record = dyn_cast<CXXRecordDecl>(D)) {
2693 if (Record->hasAttr<ExcludeFromExplicitInstantiationAttr>())
2701 if (Record->isInjectedClassName() || Record->getPreviousDecl() ||
2706 assert(MSInfo &&
"No member specialization information?");
2732 assert(Pattern &&
"Missing instantiated-from-template information");
2734 if (!Record->getDefinition()) {
2755 Record->getTemplateSpecializationKind() ==
2757 Record->setTemplateSpecializationKind(TSK);
2762 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
2766 }
else if (
auto *Enum = dyn_cast<EnumDecl>(D)) {
2768 assert(MSInfo &&
"No member specialization information?");
2775 PointOfInstantiation, TSK, Enum,
2781 if (Enum->getDefinition())
2784 EnumDecl *Pattern = Enum->getTemplateInstantiationPattern();
2785 assert(Pattern &&
"Missing instantiated-from-template information");
2791 InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
2796 }
else if (
auto *Field = dyn_cast<FieldDecl>(D)) {
2803 ClassPattern->
lookup(Field->getDeclName());
2838 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2841 return Instantiator.TransformStmt(S);
2849 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2852 return Instantiator.TransformExpr(E);
2857 bool CXXDirectInit) {
2858 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2861 return Instantiator.TransformInitializer(Init, CXXDirectInit);
2870 TemplateInstantiator Instantiator(*
this, TemplateArgs,
2873 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
2883 TemplateInstantiator Instantiator(*
this, TemplateArgs, NNS.
getBeginLoc(),
2885 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
2892 TemplateInstantiator Instantiator(*
this, TemplateArgs, NameInfo.
getLoc(),
2894 return Instantiator.TransformDeclarationNameInfo(NameInfo);
2901 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
2904 SS.
Adopt(QualifierLoc);
2905 return Instantiator.TransformTemplateName(SS, Name, Loc);
2911 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
2914 return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
2922 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
2923 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
2924 unsigned i = PV->getFunctionScopeIndex();
2927 if (i < FD->getNumParams() && FD->getParamDecl(i) == PV)
2928 return FD->getCanonicalDecl()->getParamDecl(i);
2935 llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
2939 Current = Current->Outer) {
2942 const Decl *CheckD = D;
2944 LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
2945 if (Found != Current->LocalDecls.end())
2946 return &Found->second;
2950 if (
const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
2957 if (!Current->CombineWithOuterScope)
2963 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
2964 isa<TemplateTemplateParmDecl>(D))
2969 if (RD->isLocalClass())
2974 if (isa<EnumDecl>(D))
2980 assert(isa<LabelDecl>(D) &&
"declaration not instantiated in this scope");
2986 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2987 if (Stored.isNull()) {
2991 while (Current->CombineWithOuterScope && Current->Outer) {
2992 Current = Current->Outer;
2993 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
2994 "Instantiated local in inner and outer scopes");
2999 Pack->push_back(cast<VarDecl>(Inst));
3001 assert(Stored.get<
Decl *>() == Inst &&
"Already instantiated this local");
3009 Pack->push_back(Inst);
3016 Current && Current->CombineWithOuterScope; Current = Current->Outer)
3017 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
3018 "Creating local pack after instantiation of local");
3022 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
3025 ArgumentPacks.push_back(Pack);
3030 unsigned NumExplicitArgs) {
3031 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
3032 "Already have a partially-substituted pack");
3033 assert((!PartiallySubstitutedPack
3034 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
3035 "Wrong number of arguments in partially-substituted pack");
3036 PartiallySubstitutedPack = Pack;
3037 ArgsInPartiallySubstitutedPack = ExplicitArgs;
3038 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
3043 unsigned *NumExplicitArgs)
const {
3045 *ExplicitArgs =
nullptr;
3046 if (NumExplicitArgs)
3047 *NumExplicitArgs = 0;
3050 Current = Current->Outer) {
3051 if (Current->PartiallySubstitutedPack) {
3053 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
3054 if (NumExplicitArgs)
3055 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
3057 return Current->PartiallySubstitutedPack;
3060 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)
unsigned getNumBases() const
Retrieves the number of base classes of this class.
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)...
VarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
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.
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.
MatchFinder::MatchResult MatchResult
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...
bool isParameterPack() const
Whether this declaration is a parameter pack.
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...
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)
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
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...
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...
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
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.
static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, VarDecl *ParamPack, SourceLocation NameLoc, ArrayRef< VarDecl *> Params)
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.
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.
VarDecl * getExpansion(unsigned I) const
Get an expansion of the parameter pack by index.
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.
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
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.
void InstantiatedLocalPackArg(const Decl *D, VarDecl *Inst)
void setHasInheritedDefaultArg(bool I=true)
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...
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 or init-capture pack that has been substituted bu...
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.
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given stream.
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.
VarDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
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...
bool isClassScopeExplicitSpecialization() const
Is this an explicit specialization at class scope (within the class that owns the primary template)...
bool isClassScopeExplicitSpecialization() const
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack...
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()
void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD, bool ConstexprOnly=false)
MarkVirtualMembersReferenced - Will mark all members of the given CXXRecordDecl referenced.
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...
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 ...
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.
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)
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate members of the class templa...
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.
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...