39#include "llvm/ADT/StringExtras.h"
40#include "llvm/Support/ErrorHandling.h"
41#include "llvm/Support/TimeProfiler.h"
54 const Decl *NextDecl =
nullptr;
56 bool ClearRelativeToPrimary =
true;
57 static Response Done() {
62 static Response ChangeDecl(
const Decl *ND) {
67 static Response ChangeDecl(
const DeclContext *Ctx) {
73 static Response UseNextDecl(
const Decl *CurDecl) {
77 static Response DontClearRelativeToPrimaryNextDecl(
const Decl *CurDecl) {
78 Response R = Response::UseNextDecl(CurDecl);
79 R.ClearRelativeToPrimary =
false;
87 bool SkipForSpecialization) {
91 return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);
95 !isa<VarTemplatePartialSpecializationDecl>(VarTemplSpec))
96 return Response::Done();
101 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
105 if (!SkipForSpecialization)
106 Result.addOuterTemplateArguments(
109 if (Partial->isMemberSpecialization())
110 return Response::Done();
113 if (!SkipForSpecialization)
114 Result.addOuterTemplateArguments(
118 return Response::Done();
120 return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);
132 for (
unsigned I = 0, N = TTP->
getDepth() + 1; I != N; ++I)
133 Result.addOuterTemplateArguments(std::nullopt);
134 return Response::Done();
137Response HandlePartialClassTemplateSpec(
140 if (!SkipForSpecialization)
142 return Response::Done();
149 bool SkipForSpecialization) {
153 !isa<ClassTemplatePartialSpecializationDecl>(ClassTemplSpec))
154 return Response::Done();
156 if (!SkipForSpecialization)
157 Result.addOuterTemplateArguments(
166 return Response::Done();
174 return Response::ChangeDecl(InstFromPartialTempl->getLexicalDeclContext());
176 return Response::UseNextDecl(ClassTemplSpec);
182 bool ForConstraintInstantiation) {
184 if (!RelativeToPrimary &&
185 Function->getTemplateSpecializationKindForInstantiation() ==
187 return Response::Done();
189 if (!RelativeToPrimary &&
194 return Response::UseNextDecl(
Function);
196 Function->getTemplateSpecializationArgs()) {
199 TemplateArgs->asArray(),
204 assert(
Function->getPrimaryTemplate() &&
"No function template?");
205 if (
Function->getPrimaryTemplate()->isMemberSpecialization())
206 return Response::Done();
209 if (!ForConstraintInstantiation &&
211 return Response::Done();
213 }
else if (
Function->getDescribedFunctionTemplate()) {
215 (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
216 "Outer template not instantiated?");
223 Function->getNonTransparentDeclContext()->isFileContext() &&
225 return Response::ChangeDecl(
Function->getLexicalDeclContext());
228 if (ForConstraintInstantiation &&
Function->getFriendObjectKind())
229 return Response::ChangeDecl(
Function->getLexicalDeclContext());
230 return Response::UseNextDecl(
Function);
235 if (!isa<ClassTemplateSpecializationDecl>(FTD->
getDeclContext())) {
236 Result.addOuterTemplateArguments(
264 if (TSTy->isCurrentInstantiation()) {
265 auto *RD = TSTy->getCanonicalTypeInternal()->getAsCXXRecordDecl();
267 Arguments = CTD->getInjectedTemplateArgs();
269 dyn_cast<ClassTemplateSpecializationDecl>(RD))
273 Result.addOuterTemplateArguments(
289 bool ForConstraintInstantiation) {
292 (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
293 "Outer template not instantiated?");
294 if (ClassTemplate->isMemberSpecialization())
295 return Response::Done();
296 if (ForConstraintInstantiation)
297 Result.addOuterTemplateArguments(
const_cast<CXXRecordDecl *
>(Rec),
298 ClassTemplate->getInjectedTemplateArgs(),
305 return Response::Done();
310 if (ForConstraintInstantiation && IsFriend &&
319 return Response::ChangeDecl(LCD);
321 return Response::UseNextDecl(Rec);
324Response HandleImplicitConceptSpecializationDecl(
327 Result.addOuterTemplateArguments(
331 return Response::UseNextDecl(CSD);
334Response HandleGenericDeclContext(
const Decl *CurDecl) {
335 return Response::UseNextDecl(CurDecl);
371 const FunctionDecl *Pattern,
bool ForConstraintInstantiation,
372 bool SkipForSpecialization) {
373 assert((ND || DC) &&
"Can't find arguments for a decl if one isn't provided");
378 const Decl *CurDecl = ND;
384 Result.addOuterTemplateArguments(
const_cast<NamedDecl *
>(ND), *Innermost,
394 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl))
395 HandleDefaultTempArgIntoTempTempParam(TTP,
Result);
396 CurDecl = Response::UseNextDecl(CurDecl).NextDecl;
401 if (
const auto *VarTemplSpec =
402 dyn_cast<VarTemplateSpecializationDecl>(CurDecl)) {
403 R = HandleVarTemplateSpec(VarTemplSpec,
Result, SkipForSpecialization);
404 }
else if (
const auto *PartialClassTemplSpec =
405 dyn_cast<ClassTemplatePartialSpecializationDecl>(CurDecl)) {
406 R = HandlePartialClassTemplateSpec(PartialClassTemplSpec,
Result,
407 SkipForSpecialization);
408 }
else if (
const auto *ClassTemplSpec =
409 dyn_cast<ClassTemplateSpecializationDecl>(CurDecl)) {
410 R = HandleClassTemplateSpec(ClassTemplSpec,
Result,
411 SkipForSpecialization);
412 }
else if (
const auto *
Function = dyn_cast<FunctionDecl>(CurDecl)) {
414 ForConstraintInstantiation);
415 }
else if (
const auto *Rec = dyn_cast<CXXRecordDecl>(CurDecl)) {
416 R = HandleRecordDecl(Rec,
Result,
Context, ForConstraintInstantiation);
417 }
else if (
const auto *CSD =
418 dyn_cast<ImplicitConceptSpecializationDecl>(CurDecl)) {
419 R = HandleImplicitConceptSpecializationDecl(CSD,
Result);
420 }
else if (
const auto *FTD = dyn_cast<FunctionTemplateDecl>(CurDecl)) {
421 R = HandleFunctionTemplateDecl(FTD,
Result);
422 }
else if (
const auto *CTD = dyn_cast<ClassTemplateDecl>(CurDecl)) {
423 R = Response::ChangeDecl(CTD->getLexicalDeclContext());
424 }
else if (!isa<DeclContext>(CurDecl)) {
425 R = Response::DontClearRelativeToPrimaryNextDecl(CurDecl);
426 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl)) {
427 R = HandleDefaultTempArgIntoTempTempParam(TTP,
Result);
430 R = HandleGenericDeclContext(CurDecl);
435 if (R.ClearRelativeToPrimary)
436 RelativeToPrimary =
false;
438 CurDecl = R.NextDecl;
480 llvm_unreachable(
"Invalid SynthesisKind!");
510 AlreadyInstantiating = !Inst.Entity ?
false :
512 .insert({Inst.Entity->getCanonicalDecl(), Inst.Kind})
523 PointOfInstantiation, InstantiationRange, Entity) {}
530 PointOfInstantiation, InstantiationRange, Entity) {}
540 Template, TemplateArgs) {}
550 TemplateArgs, &DeductionInfo) {
564 PointOfInstantiation, InstantiationRange, Template, nullptr,
565 TemplateArgs, &DeductionInfo) {}
575 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
576 TemplateArgs, &DeductionInfo) {}
586 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
587 TemplateArgs, &DeductionInfo) {}
595 PointOfInstantiation, InstantiationRange, Param, nullptr,
605 PointOfInstantiation, InstantiationRange, Param, Template,
615 PointOfInstantiation, InstantiationRange, Param, Template,
624 PointOfInstantiation, InstantiationRange, Param, Template,
633 PointOfInstantiation, InstantiationRange, nullptr,
634 nullptr,
std::nullopt, &DeductionInfo) {
643 PointOfInstantiation, InstantiationRange, nullptr,
644 nullptr,
std::nullopt) {}
651 PointOfInstantiation, InstantiationRange, nullptr,
652 nullptr,
std::nullopt, &DeductionInfo) {
661 PointOfInstantiation, InstantiationRange, Template, nullptr,
670 PointOfInstantiation, InstantiationRange, Template, nullptr,
671 {}, &DeductionInfo) {}
679 PointOfInstantiation, InstantiationRange, Template) {}
687 PointOfInstantiation, InstantiationRange, Template) {}
694 PointOfInstantiation, InstantiationRange, Entity) {}
714 if (!Active.isInstantiationRecord()) {
724 "forgot to remove a lookup module for a template instantiation");
743 if (!AlreadyInstantiating) {
747 {Active.Entity->getCanonicalDecl(), Active.Kind});
761 llvm::raw_string_ostream
OS(
Result);
762 llvm::ListSeparator Comma;
763 for (
const Expr *Arg : Args) {
765 Arg->IgnoreParens()->printPretty(
OS,
nullptr,
771bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
781 SemaRef.
Diag(PointOfInstantiation,
782 diag::err_template_recursion_depth_exceeded)
784 << InstantiationRange;
785 SemaRef.
Diag(PointOfInstantiation, diag::note_template_recursion_depth)
797 SkipStart = Limit / 2 + Limit % 2;
802 unsigned InstantiationIdx = 0;
807 ++Active, ++InstantiationIdx) {
809 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
810 if (InstantiationIdx == SkipStart) {
813 diag::note_instantiation_contexts_suppressed)
819 switch (Active->Kind) {
821 Decl *D = Active->Entity;
823 unsigned DiagID = diag::note_template_member_class_here;
824 if (isa<ClassTemplateSpecializationDecl>(
Record))
825 DiagID = diag::note_template_class_instantiation_here;
827 <<
Record << Active->InstantiationRange;
831 DiagID = diag::note_function_template_spec_here;
833 DiagID = diag::note_template_member_function_here;
836 << Active->InstantiationRange;
837 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
839 VD->isStaticDataMember()?
840 diag::note_template_static_data_member_def_here
841 : diag::note_template_variable_def_here)
843 << Active->InstantiationRange;
844 }
else if (
EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
846 diag::note_template_enum_def_here)
848 << Active->InstantiationRange;
849 }
else if (
FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
851 diag::note_template_nsdmi_here)
852 << FD << Active->InstantiationRange;
855 diag::note_template_class_instantiation_here)
856 << CTD << Active->InstantiationRange;
859 diag::note_template_type_alias_instantiation_here)
860 << cast<TypeAliasTemplateDecl>(D)
861 << Active->InstantiationRange;
867 TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
869 llvm::raw_svector_ostream
OS(TemplateArgsStr);
874 diag::note_default_arg_instantiation_here)
876 << Active->InstantiationRange;
883 diag::note_explicit_template_arg_substitution_here)
886 Active->TemplateArgs,
887 Active->NumTemplateArgs)
888 << Active->InstantiationRange;
894 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
896 diag::note_function_template_deduction_instantiation_here)
899 Active->TemplateArgs,
900 Active->NumTemplateArgs)
901 << Active->InstantiationRange;
903 bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
904 isa<VarTemplateSpecializationDecl>(Active->Entity);
905 bool IsTemplate =
false;
907 if (
auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
909 Params = D->getTemplateParameters();
910 }
else if (
auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
912 Params = D->getTemplateParameters();
913 }
else if (
auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
915 Params = D->getTemplateParameters();
917 llvm_unreachable(
"unexpected template kind");
921 diag::note_deduced_template_arg_substitution_here)
922 << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
924 Active->NumTemplateArgs)
925 << Active->InstantiationRange;
931 ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
935 llvm::raw_svector_ostream
OS(TemplateArgsStr);
940 diag::note_default_function_arg_instantiation_here)
942 << Active->InstantiationRange;
947 NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
950 Name = std::string(
" '") + Parm->
getName().str() +
"'";
953 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
954 TemplateParams = Template->getTemplateParameters();
957 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
958 ->getTemplateParameters();
960 diag::note_prior_template_arg_substitution)
961 << isa<TemplateTemplateParmDecl>(Parm)
964 Active->TemplateArgs,
965 Active->NumTemplateArgs)
966 << Active->InstantiationRange;
972 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
973 TemplateParams = Template->getTemplateParameters();
976 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
977 ->getTemplateParameters();
980 diag::note_template_default_arg_checking)
982 Active->TemplateArgs,
983 Active->NumTemplateArgs)
984 << Active->InstantiationRange;
990 diag::note_evaluating_exception_spec_here)
991 << cast<FunctionDecl>(Active->Entity);
996 diag::note_template_exception_spec_instantiation_here)
997 << cast<FunctionDecl>(Active->Entity)
998 << Active->InstantiationRange;
1003 diag::note_template_requirement_instantiation_here)
1004 << Active->InstantiationRange;
1008 diag::note_template_requirement_params_instantiation_here)
1009 << Active->InstantiationRange;
1014 diag::note_nested_requirement_here)
1015 << Active->InstantiationRange;
1020 diag::note_in_declaration_of_implicit_special_member)
1021 << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
1026 diag::note_in_declaration_of_implicit_equality_comparison);
1032 auto *FD = dyn_cast<FunctionDecl>(Active->Entity);
1036 auto *MD = cast<CXXMethodDecl>(FD);
1038 diag::note_member_synthesized_at)
1044 .getNonReferenceType()
1045 .getUnqualifiedType();
1047 diag::note_comparison_synthesized_at)
1055 diag::note_rewriting_operator_as_spaceship);
1060 diag::note_in_binding_decl_init)
1061 << cast<BindingDecl>(Active->Entity);
1066 diag::note_due_to_dllexported_class)
1067 << cast<CXXRecordDecl>(Active->Entity) << !
getLangOpts().CPlusPlus11;
1072 diag::note_building_builtin_dump_struct_call)
1082 diag::note_lambda_substitution_here);
1085 unsigned DiagID = 0;
1086 if (!Active->Entity) {
1088 diag::note_nested_requirement_here)
1089 << Active->InstantiationRange;
1092 if (isa<ConceptDecl>(Active->Entity))
1093 DiagID = diag::note_concept_specialization_here;
1094 else if (isa<TemplateDecl>(Active->Entity))
1095 DiagID = diag::note_checking_constraints_for_template_id_here;
1096 else if (isa<VarTemplatePartialSpecializationDecl>(Active->Entity))
1097 DiagID = diag::note_checking_constraints_for_var_spec_id_here;
1098 else if (isa<ClassTemplatePartialSpecializationDecl>(Active->Entity))
1099 DiagID = diag::note_checking_constraints_for_class_spec_id_here;
1101 assert(isa<FunctionDecl>(Active->Entity));
1102 DiagID = diag::note_checking_constraints_for_function_here;
1105 llvm::raw_svector_ostream
OS(TemplateArgsStr);
1107 if (!isa<FunctionDecl>(Active->Entity)) {
1111 Diags.
Report(Active->PointOfInstantiation, DiagID) <<
OS.str()
1112 << Active->InstantiationRange;
1117 diag::note_constraint_substitution_here)
1118 << Active->InstantiationRange;
1122 diag::note_constraint_normalization_here)
1123 << cast<NamedDecl>(Active->Entity)->getName()
1124 << Active->InstantiationRange;
1128 diag::note_parameter_mapping_substitution_here)
1129 << Active->InstantiationRange;
1133 diag::note_building_deduction_guide_here);
1141 return std::optional<TemplateDeductionInfo *>(
nullptr);
1146 Active != ActiveEnd;
1149 switch (Active->Kind) {
1153 if (isa<TypeAliasTemplateDecl>(Active->Entity))
1163 return std::nullopt;
1170 return std::nullopt;
1191 assert(Active->DeductionInfo &&
"Missing deduction info pointer");
1192 return Active->DeductionInfo;
1203 return std::nullopt;
1217 if (Active->SavedInNonInstantiationSFINAEContext)
1218 return std::optional<TemplateDeductionInfo *>(
nullptr);
1221 return std::nullopt;
1228 class TemplateInstantiator :
public TreeTransform<TemplateInstantiator> {
1233 bool EvaluateConstraints =
true;
1238 TemplateInstantiator(
Sema &SemaRef,
1241 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
1244 void setEvaluateConstraints(
bool B) {
1245 EvaluateConstraints = B;
1247 bool getEvaluateConstraints() {
1248 return EvaluateConstraints;
1256 bool AlreadyTransformed(
QualType T);
1268 this->Entity = Entity;
1271 unsigned TransformTemplateDepth(
unsigned Depth) {
1276 int Index = getSema().ArgumentPackSubstitutionIndex;
1278 return std::nullopt;
1285 bool &ShouldExpand,
bool &RetainExpansion,
1286 std::optional<unsigned> &NumExpansions) {
1287 return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
1288 PatternRange, Unexpanded,
1295 void ExpandingFunctionParameterPack(
ParmVarDecl *Pack) {
1305 unsigned Depth, Index;
1308 Result = TemplateArgs(Depth, Index);
1324 unsigned Depth, Index;
1334 void transformAttrs(
Decl *Old,
Decl *New) {
1341 for (
auto *New : NewDecls)
1343 Old, cast<VarDecl>(New));
1347 assert(NewDecls.size() == 1 &&
1348 "should only have multiple expansions for a pack");
1349 Decl *New = NewDecls.front();
1354 auto *NewMD = dyn_cast<CXXMethodDecl>(New);
1356 auto *OldMD = dyn_cast<CXXMethodDecl>(Old);
1357 if (
auto *NewTD = NewMD->getDescribedFunctionTemplate())
1358 NewTD->setInstantiatedFromMemberTemplate(
1359 OldMD->getDescribedFunctionTemplate());
1361 NewMD->setInstantiationOfMemberFunction(OldMD,
1369 if (
auto *DC = dyn_cast<DeclContext>(Old);
1370 DC && DC->isDependentContext() && DC->isFunctionOrMethod())
1411 NamedDecl *FirstQualifierInScope =
nullptr,
1412 bool AllowInjectedClassName =
false);
1414 const CXXAssumeAttr *TransformCXXAssumeAttr(
const CXXAssumeAttr *AA);
1415 const LoopHintAttr *TransformLoopHintAttr(
const LoopHintAttr *LH);
1416 const NoInlineAttr *TransformStmtNoInlineAttr(
const Stmt *OrigS,
1418 const NoInlineAttr *A);
1419 const AlwaysInlineAttr *
1420 TransformStmtAlwaysInlineAttr(
const Stmt *OrigS,
const Stmt *InstS,
1421 const AlwaysInlineAttr *A);
1422 const CodeAlignAttr *TransformCodeAlignAttr(
const CodeAlignAttr *CA);
1429 ExprResult TransformSubstNonTypeTemplateParmPackExpr(
1431 ExprResult TransformSubstNonTypeTemplateParmExpr(
1448 return inherited::TransformFunctionProtoType(TLB, TL);
1453 auto Type = inherited::TransformInjectedClassNameType(TLB, TL);
1456 if (
Type.isNull() &&
1463 inherited::TransformType(ICT->getInjectedSpecializationType());
1474 bool Uneval =
false) {
1476 std::vector<TemplateArgument> TArgs;
1484 "Transforming a template argument pack is only allowed in building "
1501 return inherited::TransformTemplateArgument(Input, Output, Uneval);
1504 template<
typename Fn>
1509 Fn TransformExceptionSpec);
1512 TransformFunctionTypeParam(
ParmVarDecl *OldParm,
int indexAdjustment,
1513 std::optional<unsigned> NumExpansions,
1514 bool ExpectParameterPack);
1516 using inherited::TransformTemplateTypeParmType;
1521 bool SuppressObjCLifetime);
1523 QualType BuildSubstTemplateTypeParmType(
1525 Decl *AssociatedDecl,
unsigned Index, std::optional<unsigned> PackIndex,
1531 using inherited::TransformSubstTemplateTypeParmPackType;
1535 bool SuppressObjCLifetime);
1541 ExprResult Result = inherited::TransformLambdaExpr(E);
1542 if (Result.isInvalid())
1547 assert(PVD &&
"null in a parameter list");
1548 if (!PVD->hasDefaultArg())
1550 Expr *UninstExpr = PVD->getUninstantiatedDefaultArg();
1559 { UninstExpr }, UninstExpr->
getType());
1561 PVD->setDefaultArg(ErrorResult.
get());
1578 bool Prev = EvaluateConstraints;
1579 EvaluateConstraints =
true;
1581 EvaluateConstraints = Prev;
1587 ExprResult TransReq = inherited::TransformRequiresExpr(E);
1590 assert(TransReq.
get() != E &&
1591 "Do not change value of isSatisfied for the existing expression. "
1592 "Create a new expression instead.");
1599 if (Trap.hasErrorOccurred())
1605 bool TransformRequiresExprRequirements(
1608 bool SatisfactionDetermined =
false;
1611 if (!SatisfactionDetermined) {
1612 if (
auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req))
1613 TransReq = TransformTypeRequirement(TypeReq);
1614 else if (
auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req))
1615 TransReq = TransformExprRequirement(ExprReq);
1617 TransReq = TransformNestedRequirement(
1618 cast<concepts::NestedRequirement>(Req));
1627 SatisfactionDetermined =
true;
1630 Transformed.push_back(TransReq);
1637 if (!OrigTPL || !OrigTPL->
size())
return OrigTPL;
1641 Owner, TemplateArgs);
1642 DeclInstantiator.setEvaluateConstraints(EvaluateConstraints);
1643 return DeclInstantiator.SubstTemplateParams(OrigTPL);
1661 transformNonTypeTemplateParmRef(
Decl *AssociatedDecl,
1664 std::optional<unsigned> PackIndex);
1668bool TemplateInstantiator::AlreadyTransformed(
QualType T) {
1675 getSema().MarkDeclarationsReferencedInType(Loc, T);
1700 TTP->getPosition()))
1705 if (TTP->isParameterPack()) {
1707 "Missing argument pack");
1713 "Wrong kind of template template argument");
1725 Decl *Inst = getSema().SubstDecl(D, getSema().
CurContext, TemplateArgs);
1729 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1733bool TemplateInstantiator::TransformExceptionSpec(
1740 return inherited::TransformExceptionSpec(Loc, ESI, Exceptions, Changed);
1744TemplateInstantiator::TransformFirstQualifierInScope(
NamedDecl *D,
1758 "Missing argument pack");
1768 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1771 return Tag->getDecl();
1774 getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
1779 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1783TemplateInstantiator::RebuildExceptionDecl(
VarDecl *ExceptionDecl,
1789 StartLoc, NameLoc, Name);
1791 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1795VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(
VarDecl *ExceptionDecl,
1798 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
1800 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1805TemplateInstantiator::RebuildElaboratedType(
SourceLocation KeywordLoc,
1823 SemaRef.
Diag(TagLocation, diag::err_use_with_wrong_tag)
1832 return inherited::RebuildElaboratedType(KeywordLoc, Keyword, QualifierLoc, T);
1835TemplateName TemplateInstantiator::TransformTemplateName(
1838 bool AllowInjectedClassName) {
1840 = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {
1847 TTP->getPosition()))
1857 "unexpected pack arguments in template rewrite");
1861 "unexpected nontype template argument kind in template rewrite");
1865 auto [AssociatedDecl, Final] =
1867 std::optional<unsigned> PackIndex;
1870 "Missing argument pack");
1876 return getSema().Context.getSubstTemplateTemplateParmPack(
1877 Arg, AssociatedDecl, TTP->
getIndex(), Final);
1880 PackIndex = getPackIndex(Arg);
1885 assert(!Template.
isNull() &&
"Null template template argument");
1887 "template decl to substitute is qualified?");
1891 return getSema().Context.getSubstTemplateTemplateParm(
1892 Template, AssociatedDecl, TTP->
getIndex(), PackIndex);
1897 = Name.getAsSubstTemplateTemplateParmPack()) {
1904 if (SubstPack->getFinal())
1906 return getSema().Context.getSubstTemplateTemplateParm(
1908 SubstPack->getIndex(), getPackIndex(Pack));
1911 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
1912 FirstQualifierInScope,
1913 AllowInjectedClassName);
1917TemplateInstantiator::TransformPredefinedExpr(
PredefinedExpr *E) {
1925TemplateInstantiator::TransformTemplateParmRefExpr(
DeclRefExpr *E,
1942 "unexpected pack arguments in template rewrite");
1946 "unexpected nontype template argument kind in template rewrite");
1953 std::optional<unsigned> PackIndex;
1956 "Missing argument pack");
1976 PackIndex = getPackIndex(Arg);
1980 return transformNonTypeTemplateParmRef(AssociatedDecl, NTTP, E->
getLocation(),
1984const CXXAssumeAttr *
1985TemplateInstantiator::TransformCXXAssumeAttr(
const CXXAssumeAttr *AA) {
1986 ExprResult Res = getDerived().TransformExpr(AA->getAssumption());
1990 Res = getSema().BuildCXXAssumeExpr(Res.
get(), AA->getAttrName(),
1995 return CXXAssumeAttr::CreateImplicit(getSema().
Context, Res.
get(),
2000TemplateInstantiator::TransformLoopHintAttr(
const LoopHintAttr *LH) {
2001 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).get();
2003 if (TransformedExpr == LH->getValue())
2012 return LoopHintAttr::CreateImplicit(getSema().
Context, LH->getOption(),
2013 LH->getState(), TransformedExpr, *LH);
2015const NoInlineAttr *TemplateInstantiator::TransformStmtNoInlineAttr(
2016 const Stmt *OrigS,
const Stmt *InstS,
const NoInlineAttr *A) {
2022const AlwaysInlineAttr *TemplateInstantiator::TransformStmtAlwaysInlineAttr(
2023 const Stmt *OrigS,
const Stmt *InstS,
const AlwaysInlineAttr *A) {
2030const CodeAlignAttr *
2031TemplateInstantiator::TransformCodeAlignAttr(
const CodeAlignAttr *CA) {
2032 Expr *TransformedExpr = getDerived().TransformExpr(CA->getAlignment()).get();
2033 return getSema().BuildCodeAlignAttr(*CA, TransformedExpr);
2036ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
2039 std::optional<unsigned> PackIndex) {
2044 auto SubstParamType = [&] {
2051 T = cast<PackExpansionType>(T)->getPattern();
2055 bool refParam =
false;
2061 Expr *argExpr =
arg.getAsExpr();
2066 QualType paramType = SubstParamType();
2081 VD = cast_or_null<ValueDecl>(
2087 QualType paramType =
arg.getNonTypeTemplateArgumentType();
2088 assert(!paramType.
isNull() &&
"type substitution failed for param type");
2089 assert(!paramType->
isDependentType() &&
"param type still dependent");
2093 QualType paramType =
arg.getNonTypeTemplateArgumentType();
2104 Expr *resultExpr = result.
get();
2108 AssociatedDecl, parm->
getIndex(), PackIndex, refParam);
2112TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
2122 return transformNonTypeTemplateParmRef(
2128TemplateInstantiator::TransformSubstNonTypeTemplateParmExpr(
2131 if (!isa<ConstantExpr>(SubstReplacement.
get()))
2161 SubstReplacement.
get(), SugaredConverted,
2173 return getSema().BuildDeclarationNameExpr(
CXXScopeSpec(), NameInfo, PD);
2184 return RebuildVarDeclRefExpr(VD, E->
getExprLoc());
2206 getSema().MarkFunctionParmPackReferenced(PackExpr);
2211TemplateInstantiator::TransformFunctionParmPackRefExpr(
DeclRefExpr *E,
2214 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
2215 = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
2216 assert(Found &&
"no instantiation for parameter pack");
2218 Decl *TransformedDecl;
2219 if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
2228 getSema().MarkFunctionParmPackReferenced(PackExpr);
2232 TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
2234 TransformedDecl = Found->get<
Decl*>();
2238 return RebuildVarDeclRefExpr(cast<VarDecl>(TransformedDecl), E->
getExprLoc());
2242TemplateInstantiator::TransformDeclRefExpr(
DeclRefExpr *E) {
2249 return TransformTemplateParmRefExpr(E, NTTP);
2256 if (
VarDecl *PD = dyn_cast<VarDecl>(D))
2258 return TransformFunctionParmPackRefExpr(E, PD);
2260 return inherited::TransformDeclRefExpr(E);
2263ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
2266 getDescribedFunctionTemplate() &&
2267 "Default arg expressions are never formed in dependent cases.");
2273template<
typename Fn>
2278 Fn TransformExceptionSpec) {
2281 return inherited::TransformFunctionProtoType(
2282 TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
2285ParmVarDecl *TemplateInstantiator::TransformFunctionTypeParam(
2287 std::optional<unsigned> NumExpansions,
bool ExpectParameterPack) {
2289 OldParm, TemplateArgs, indexAdjustment, NumExpansions,
2290 ExpectParameterPack, EvaluateConstraints);
2296QualType TemplateInstantiator::BuildSubstTemplateTypeParmType(
2298 Decl *AssociatedDecl,
unsigned Index, std::optional<unsigned> PackIndex,
2304 if (SuppressObjCLifetime) {
2306 RQs = Replacement.getQualifiers();
2317 QualType Result = getSema().Context.getSubstTemplateTypeParmType(
2318 Replacement, AssociatedDecl, Index, PackIndex);
2326TemplateInstantiator::TransformTemplateTypeParmType(
TypeLocBuilder &TLB,
2328 bool SuppressObjCLifetime) {
2352 "unexpected pack arguments in template rewrite");
2356 "unexpected nontype template argument kind in template rewrite");
2358 assert(isa<TemplateTypeParmType>(NewT) &&
2359 "type parm not rewritten to type parm");
2365 auto [AssociatedDecl, Final] =
2367 std::optional<unsigned> PackIndex;
2370 "Missing argument pack");
2376 QualType Result = getSema().Context.getSubstTemplateTypeParmPackType(
2377 AssociatedDecl, T->
getIndex(), Final, Arg);
2385 PackIndex = getPackIndex(Arg);
2390 "Template argument kind mismatch");
2392 return BuildSubstTemplateTypeParmType(TLB, SuppressObjCLifetime, Final,
2403 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
2413QualType TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
2415 bool SuppressObjCLifetime) {
2424 Result = getSema().Context.getSubstTemplateTypeParmPackType(
2434 return BuildSubstTemplateTypeParmType(
2449 ErrorLoc = PDA.first;
2453 char *MessageBuf =
new (S.
Context)
char[Message.size()];
2454 std::copy(Message.begin(), Message.end(), MessageBuf);
2456 llvm::raw_svector_ostream
OS(Entity);
2458 char *EntityBuf =
new (S.
Context)
char[Entity.size()];
2459 std::copy(Entity.begin(), Entity.end(), EntityBuf);
2461 StringRef(EntityBuf, Entity.size()), ErrorLoc,
2462 StringRef(MessageBuf, Message.size())};
2469 llvm::raw_svector_ostream
OS(Entity);
2471 char *EntityBuf =
new (S.
Context)
char[Entity.size()];
2472 llvm::copy(Entity, EntityBuf);
2474 StringRef(EntityBuf, Entity.size()),
2475 Location, StringRef()};
2478ExprResult TemplateInstantiator::TransformRequiresTypeParams(
2492 if (getDerived().TransformFunctionTypeParams(
2493 KWLoc, Params,
nullptr,
nullptr, PTypes,
2494 &TransParams, PInfos, &ErrorIdx) ||
2495 Trap.hasErrorOccurred()) {
2501 SemaRef, Info, [&](llvm::raw_ostream &
OS) {
OS << *FailedDecl; })));
2502 return getDerived().RebuildRequiresExpr(KWLoc, Body, RE->
getLParenLoc(),
2504 TransReqs, RBraceLoc);
2515 if (AlwaysRebuild())
2516 return RebuildTypeRequirement(
2526 if (TypeInst.isInvalid())
2529 if (!TransType || Trap.hasErrorOccurred())
2531 [&] (llvm::raw_ostream&
OS) {
2534 return RebuildTypeRequirement(TransType);
2544 llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *>
2553 if (ExprInst.isInvalid())
2556 if (!TransExprRes.
isInvalid() && !Trap.hasErrorOccurred() &&
2559 if (TransExprRes.
isInvalid() || Trap.hasErrorOccurred())
2564 TransExpr = TransExprRes.
get();
2567 std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;
2569 if (RetReq.isEmpty())
2570 TransRetReq.emplace();
2571 else if (RetReq.isSubstitutionFailure())
2572 TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
2573 else if (RetReq.isTypeConstraint()) {
2575 RetReq.getTypeConstraintTemplateParameterList();
2579 if (TPLInst.isInvalid())
2584 [&] (llvm::raw_ostream&
OS) {
2585 RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()
2590 TransRetReq.emplace(TPL);
2593 assert(TransRetReq &&
"All code paths leading here must set TransRetReq");
2594 if (
Expr *E = TransExpr.dyn_cast<
Expr *>())
2596 std::move(*TransRetReq));
2597 return RebuildExprRequirement(
2603TemplateInstantiator::TransformNestedRequirement(
2608 if (AlwaysRebuild())
2617 if (!getEvaluateConstraints()) {
2619 if (TransConstraint.
isInvalid() || !TransConstraint.
get())
2626 SemaRef.
Context, TransConstraint.
get(), Satisfaction);
2639 if (ConstrInst.isInvalid())
2643 nullptr, {Req->getConstraintExpr()},
Result, TemplateArgs,
2646 TransConstraint =
Result[0];
2647 assert(!Trap.hasErrorOccurred() &&
"Substitution failures must be handled "
2648 "by CheckConstraintSatisfaction.");
2654 if (TransConstraint.
isInvalid() || !TransConstraint.
get() ||
2657 llvm::raw_svector_ostream
OS(Entity);
2660 char *EntityBuf =
new (SemaRef.
Context)
char[Entity.size()];
2661 std::copy(Entity.begin(), Entity.end(), EntityBuf);
2663 SemaRef.
Context, StringRef(EntityBuf, Entity.size()), Satisfaction);
2666 SemaRef.
Context, TransConstraint.
get(), Satisfaction);
2704 bool AllowDeducedTST) {
2706 "Cannot perform an instantiation without some context on the "
2707 "instantiation stack");
2713 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
2714 return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(T)
2715 : Instantiator.TransformType(T);
2723 "Cannot perform an instantiation without some context on the "
2724 "instantiation stack");
2738 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
2753 "Cannot perform an instantiation without some context on the "
2754 "instantiation stack");
2761 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc, Entity);
2762 return Instantiator.TransformType(T);
2797 bool EvaluateConstraints) {
2799 "Cannot perform an instantiation without some context on the "
2800 "instantiation stack");
2805 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
2806 Instantiator.setEvaluateConstraints(EvaluateConstraints);
2822 Result = Instantiator.TransformFunctionProtoType(
2823 TLB, Proto, ThisContext, ThisTypeQuals,
2825 bool &Changed) {
return false; });
2827 Result = Instantiator.TransformType(TLB, TL);
2841 bool Changed =
false;
2842 TemplateInstantiator Instantiator(*
this, Args, Loc,
DeclarationName());
2843 return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
2854 ESI, ExceptionStorage, Args))
2863 struct GetContainedInventedTypeParmVisitor :
2864 public TypeVisitor<GetContainedInventedTypeParmVisitor,
2865 TemplateTypeParmDecl *> {
2866 using TypeVisitor<GetContainedInventedTypeParmVisitor,
2919 return VisitFunctionType(T);
2952 bool EvaluateConstraints) {
2956 if (!EvaluateConstraints) {
2983 int indexAdjustment, std::optional<unsigned> NumExpansions,
2984 bool ExpectParameterPack,
bool EvaluateConstraint) {
2993 NewDI =
SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
3004 }
else if (ExpectParameterPack) {
3010 diag::err_function_parameter_pack_without_parameter_packs)
3034 GetContainedInventedTypeParmVisitor().Visit(OldDI->
getType())) {
3036 auto *Inst = cast_or_null<TemplateTypeParmDecl>(
3041 if (Inst && !Inst->getTypeConstraint()) {
3113 "Cannot perform an instantiation without some context on the "
3114 "instantiation stack");
3116 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
3118 return Instantiator.TransformFunctionTypeParams(
3119 Loc, Params,
nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
3138 Diag(Param->
getBeginLoc(), diag::err_recursive_default_argument) << FD;
3150 std::unique_ptr<LocalInstantiationScope> LIS;
3159 LIS = std::make_unique<LocalInstantiationScope>(*
this);
3162 if (addInstantiatedParametersToScope(FD, PatternFD, *LIS, TemplateArgs))
3165 if (PrimaryTemplate && PrimaryTemplate->
isOutOfLine()) {
3171 CurrentTemplateArgumentList->
asArray(),
true);
3193 Result = InitSeq.Perform(*
this, Entity, Kind, ResultE);
3226 for (
const auto &
Base : Pattern->
bases()) {
3227 if (!
Base.getType()->isDependentType()) {
3229 if (RD->isInvalidDecl())
3238 if (
Base.isPackExpansion()) {
3244 bool ShouldExpand =
false;
3245 bool RetainExpansion =
false;
3246 std::optional<unsigned> NumExpansions;
3248 Base.getSourceRange(),
3250 TemplateArgs, ShouldExpand,
3259 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3264 Base.getSourceRange().getBegin(),
3273 Base.getSourceRange(),
3275 Base.getAccessSpecifierAsWritten(),
3278 InstantiatedBases.push_back(InstantiatedBase);
3287 EllipsisLoc =
Base.getEllipsisLoc();
3291 Base.getSourceRange().getBegin(),
3296 Base.getSourceRange().getBegin(),
3307 Base.getSourceRange(),
3309 Base.getAccessSpecifierAsWritten(),
3312 InstantiatedBases.push_back(InstantiatedBase);
3366 Pattern, PatternDef, TSK, Complain))
3369 llvm::TimeTraceScope TimeScope(
"InstantiateClass", [&]() {
3371 llvm::raw_string_ostream
OS(Name);
3377 Pattern = PatternDef;
3383 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3385 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
3386 Spec->setTemplateSpecializationKind(TSK);
3387 Spec->setPointOfInstantiation(PointOfInstantiation);
3395 "instantiating class definition");
3413 SavePendingParsedClassStateRAII SavedPendingParsedClassState(*
this);
3439 bool MightHaveConstexprVirtualFunctions =
false;
3450 if (
Member->getDeclContext() != Pattern)
3457 if (isa<BlockDecl>(
Member) ||
3458 (isa<CXXRecordDecl>(
Member) && cast<CXXRecordDecl>(
Member)->isLambda()))
3461 if (
Member->isInvalidDecl()) {
3468 if (
FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
3469 Fields.push_back(Field);
3470 }
else if (
EnumDecl *
Enum = dyn_cast<EnumDecl>(NewMember)) {
3476 Enum->isCompleteDefinition()) {
3478 assert(MSInfo &&
"no spec info for member enum specialization");
3483 if (SA->isFailed()) {
3489 }
else if (
CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewMember)) {
3492 MightHaveConstexprVirtualFunctions =
true;
3513 if (ParsingClassDepth == 0)
3518 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
3519 E = LateAttrs.end(); I != E; ++I) {
3524 auto *ND = cast<NamedDecl>(I->NewDecl);
3525 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
3527 ND->isCXXInstanceMember());
3532 I->NewDecl->addAttr(NewAttr);
3561 P->first,
P->second)) {
3574 P->first,
P->second)) {
3591 else if (MightHaveConstexprVirtualFunctions)
3623 Pattern, PatternDef, TSK,
true))
3625 Pattern = PatternDef;
3631 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3640 "instantiating enum definition");
3690 "pattern and instantiation disagree about init style");
3698 Diag(PointOfInstantiation,
3699 diag::err_default_member_initializer_not_yet_parsed)
3700 << OutermostClass << Pattern;
3701 Diag(Pattern->getEndLoc(),
3702 diag::note_default_member_initializer_not_yet_parsed);
3712 Diag(PointOfInstantiation, diag::err_default_member_initializer_cycle)
3717 "instantiating default member init");
3725 PointOfInstantiation, Instantiation,
CurContext};
3736 assert((!
Init || !isa<ParenListExpr>(
Init)) &&
"call-style init in class");
3741 L->DefaultMemberInitializerInstantiated(Instantiation);
3750 struct PartialSpecMatchResult {
3765 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
3810 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
3823 Matched.push_back(PartialSpecMatchResult());
3824 Matched.back().Partial = Partial;
3833 if (Matched.size() >= 1) {
3835 if (Matched.size() == 1) {
3848 PEnd = Matched.end();
3851 P->Partial, Best->Partial, PointOfInstantiation) ==
3858 bool Ambiguous =
false;
3860 PEnd = Matched.end();
3863 P->Partial, Best->Partial,
3864 PointOfInstantiation) != Best->Partial) {
3874 S.
Diag(PointOfInstantiation,
3875 diag::err_partial_spec_ordering_ambiguous)
3876 << ClassTemplateSpec;
3880 PEnd = Matched.end();
3882 S.
Diag(
P->Partial->getLocation(), diag::note_partial_spec_match)
3884 P->Partial->getTemplateParameters(), *
P->Args);
3899 if (
auto *PartialSpec =
3902 while (PartialSpec->getInstantiatedFromMember()) {
3905 if (PartialSpec->isMemberSpecialization())
3908 PartialSpec = PartialSpec->getInstantiatedFromMember();
3910 Pattern = PartialSpec;
3932 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
3939 ClassTemplateSpec, TSK);
3944 PointOfInstantiation, ClassTemplateSpec, Pattern.
get(),
3963 "Unexpected template specialization kind!");
3964 for (
auto *D : Instantiation->
decls()) {
3965 bool SuppressNew =
false;
3966 if (
auto *
Function = dyn_cast<FunctionDecl>(D)) {
3968 Function->getInstantiatedFromMemberFunction()) {
3970 if (
Function->isIneligibleOrNotSelected())
3973 if (
Function->getTrailingRequiresClause()) {
3981 if (
Function->hasAttr<ExcludeFromExplicitInstantiationAttr>())
3985 Function->getMemberSpecializationInfo();
3986 assert(MSInfo &&
"No member specialization information?");
4008 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
4018 std::make_pair(
Function, PointOfInstantiation));
4021 }
else if (
auto *Var = dyn_cast<VarDecl>(D)) {
4022 if (isa<VarTemplateSpecializationDecl>(Var))
4026 if (Var->
hasAttr<ExcludeFromExplicitInstantiationAttr>())
4030 assert(MSInfo &&
"No member specialization information?");
4059 }
else if (
auto *
Record = dyn_cast<CXXRecordDecl>(D)) {
4060 if (
Record->hasAttr<ExcludeFromExplicitInstantiationAttr>())
4068 if (
Record->isInjectedClassName() ||
Record->getPreviousDecl() ||
4073 assert(MSInfo &&
"No member specialization information?");
4099 assert(Pattern &&
"Missing instantiated-from-template information");
4101 if (!
Record->getDefinition()) {
4122 Record->getTemplateSpecializationKind() ==
4124 Record->setTemplateSpecializationKind(TSK);
4129 Pattern = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
4133 }
else if (
auto *
Enum = dyn_cast<EnumDecl>(D)) {
4135 assert(MSInfo &&
"No member specialization information?");
4142 PointOfInstantiation, TSK,
Enum,
4148 if (
Enum->getDefinition())
4151 EnumDecl *Pattern =
Enum->getTemplateInstantiationPattern();
4152 assert(Pattern &&
"Missing instantiated-from-template information");
4163 }
else if (
auto *Field = dyn_cast<FieldDecl>(D)) {
4170 ClassPattern->
lookup(Field->getDeclName());
4206 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4209 return Instantiator.TransformStmt(S);
4216 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4218 return Instantiator.TransformTemplateArgument(Input, Output);
4225 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4227 return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(), Out);
4235 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4238 return Instantiator.TransformExpr(E);
4254 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4256 Instantiator.setEvaluateConstraints(
false);
4257 return Instantiator.TransformExpr(E);
4262 bool CXXDirectInit) {
4263 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4265 return Instantiator.TransformInitializer(
Init, CXXDirectInit);
4274 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4277 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
4287 TemplateInstantiator Instantiator(*
this, TemplateArgs, NNS.
getBeginLoc(),
4289 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
4296 TemplateInstantiator Instantiator(*
this, TemplateArgs, NameInfo.
getLoc(),
4298 return Instantiator.TransformDeclarationNameInfo(NameInfo);
4305 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
4308 SS.
Adopt(QualifierLoc);
4309 return Instantiator.TransformTemplateName(SS, Name, Loc);
4317 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
4318 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
4319 unsigned i = PV->getFunctionScopeIndex();
4322 if (i < FD->getNumParams() && FD->getParamDecl(i) == PV)
4330llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
4334 Current = Current->Outer) {
4337 const Decl *CheckD = D;
4339 LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
4340 if (Found != Current->LocalDecls.end())
4341 return &Found->second;
4345 if (
const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
4352 if (!Current->CombineWithOuterScope)
4358 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
4359 isa<TemplateTemplateParmDecl>(D))
4364 if (RD->isLocalClass())
4369 if (isa<EnumDecl>(D))
4374 if (isa<TypedefNameDecl>(D) &&
4381 assert(isa<LabelDecl>(D) &&
"declaration not instantiated in this scope");
4387 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
4388 if (Stored.isNull()) {
4392 while (Current->CombineWithOuterScope && Current->Outer) {
4393 Current = Current->Outer;
4394 assert(!Current->LocalDecls.contains(D) &&
4395 "Instantiated local in inner and outer scopes");
4400 Pack->push_back(cast<VarDecl>(Inst));
4402 assert(Stored.get<
Decl *>() == Inst &&
"Already instantiated this local");
4410 Pack->push_back(Inst);
4417 Current && Current->CombineWithOuterScope; Current = Current->Outer)
4418 assert(!Current->LocalDecls.contains(D) &&
4419 "Creating local pack after instantiation of local");
4423 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
4426 ArgumentPacks.push_back(Pack);
4431 if (llvm::is_contained(*Pack, D))
4438 unsigned NumExplicitArgs) {
4439 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
4440 "Already have a partially-substituted pack");
4441 assert((!PartiallySubstitutedPack
4442 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
4443 "Wrong number of arguments in partially-substituted pack");
4444 PartiallySubstitutedPack = Pack;
4445 ArgsInPartiallySubstitutedPack = ExplicitArgs;
4446 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
4451 unsigned *NumExplicitArgs)
const {
4453 *ExplicitArgs =
nullptr;
4454 if (NumExplicitArgs)
4455 *NumExplicitArgs = 0;
4458 Current = Current->Outer) {
4459 if (Current->PartiallySubstitutedPack) {
4461 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
4462 if (NumExplicitArgs)
4463 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
4465 return Current->PartiallySubstitutedPack;
4468 if (!Current->CombineWithOuterScope)
This file provides AST data structures related to concepts.
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines the C++ template declaration subclasses.
Defines Expressions and AST nodes for C++2a concepts.
static void print(llvm::raw_ostream &OS, const T &V, ASTContext &, QualType)
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
MatchFinder::MatchResult MatchResult
static const Decl * getCanonicalParmVarDecl(const Decl *D)
static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T)
static concepts::Requirement::SubstitutionDiagnostic * createSubstDiag(Sema &S, TemplateDeductionInfo &Info, concepts::EntityPrinter Printer)
static ActionResult< CXXRecordDecl * > getPatternForClassTemplateSpecialization(Sema &S, SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK)
Get the instantiation pattern to use to instantiate the definition of a given ClassTemplateSpecializa...
static std::string convertCallArgsToString(Sema &S, llvm::ArrayRef< const Expr * > Args)
static TemplateArgument getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg)
Defines utilities for dealing with stack allocation and stack space.
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
virtual void HandleTagDeclDefinition(TagDecl *D)
HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
const clang::PrintingPolicy & getPrintingPolicy() const
const TargetInfo & getTargetInfo() const
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
QualType getOriginalType() const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
Attr - This represents one attribute.
An attributed type is a type to which a type attribute has been applied.
QualType getModifiedType() const
QualType getPointeeType() const
Represents a base class of a C++ class.
A default argument (C++ [dcl.fct.default]).
SourceLocation getUsedLocation() const
Retrieve the location where this default argument was actually used.
const ParmVarDecl * getParam() const
Represents a static or instance method of a struct/union/class.
Represents a C++ struct/union/class.
Decl * getLambdaContextDecl() const
Retrieve the declaration that provides additional context for a lambda, when the normal declaration c...
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
bool isLambda() const
Determine whether this class describes a lambda function object.
CXXRecordDecl * getDefinition() const
unsigned getNumBases() const
Retrieves the number of base classes of this class.
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
Represents a C++ nested-name-specifier or a global scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Declaration of a class template.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations() const
Retrieve the set of partial specializations of this class template.
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
Represents a class template specialization, which refers to a class template with a given set of temp...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
bool isClassScopeExplicitSpecialization() const
Is this an explicit specialization at class scope (within the class that owns the primary template)?...
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the class template or class template partial specialization which was specialized by this.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate members of the class templa...
void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this class template specialization is actually an instantiation of the given class template...
NamedDecl * getFoundDecl() const
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
bool HasSubstitutionFailure()
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
bool isFileContext() const
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
A reference to a declared variable, function, enum, etc.
SourceLocation getLocation() const
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
bool isParameterPack() const
Whether this declaration is a parameter pack.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
bool isFileContextDecl() const
static Decl * castFromDeclContext(const DeclContext *)
unsigned getTemplateDepth() const
Determine the number of levels of template parameter surrounding this declaration.
DeclContext * getNonTransparentDeclContext()
Return the non transparent context.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setLocation(SourceLocation L)
bool isDefinedOutsideFunctionOrMethod() const
isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...
DeclContext * getDeclContext()
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
The name of a declaration.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
SourceLocation getOuterLocStart() const
Return start of source range taking into account any outer template declarations.
SourceLocation getBeginLoc() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
Represents an extended vector type where either the type or size is dependent.
QualType getElementType() const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
bool hasFatalErrorOccurred() const
unsigned getTemplateBacktraceLimit() const
Retrieve the maximum number of template instantiation notes to emit along with a given diagnostic.
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
QualType getNamedType() const
Retrieve the type named by the qualified-id.
RAII object that enters a new expression evaluation context.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For an enumeration member that was instantiated from a member enumeration of a templated class,...
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
EnumDecl * getDefinition() const
This represents one expression.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Represents a member of a struct/union/class.
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Represents a function declaration or definition.
ArrayRef< ParmVarDecl * > parameters() const
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
VarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
VarDecl * getExpansion(unsigned I) const
Get an expansion of the parameter pack by index.
VarDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
unsigned getNumExpansions() const
Get the number of parameters in this parameter pack.
SourceLocation getParameterPackLocation() const
Get the location of the parameter pack.
static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, VarDecl *ParamPack, SourceLocation NameLoc, ArrayRef< VarDecl * > Params)
Represents a prototype with parameter type info, e.g.
ExtProtoInfo getExtProtoInfo() const
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
ArrayRef< ParmVarDecl * > getParams() const
Interesting information about a specific parameter that can't simply be reflected in parameter's type...
FunctionType - C99 6.7.5.3 - Function Declarators.
QualType getReturnType() const
One of these records is kept for each identifier that is lexed.
ArrayRef< TemplateArgument > getTemplateArguments() const
const TypeClass * getTypePtr() const
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
Describes the sequence of initializations required to initialize a given object or reference with a s...
Describes an entity that is being initialized.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
Wrapper for source info for injected class names of class templates.
The injected class name of a C++ class template or class template partial specialization.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
A stack-allocated class that identifies which local variable declaration instantiations are present i...
void SetPartiallySubstitutedPack(NamedDecl *Pack, const TemplateArgument *ExplicitArgs, unsigned NumExplicitArgs)
Note that the given parameter pack has been partially substituted via explicit specification of templ...
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
bool isLocalPackExpansion(const Decl *D)
Determine whether D is a pack expansion created in this scope.
static void deleteScopes(LocalInstantiationScope *Scope, LocalInstantiationScope *Outermost)
deletes the given scope, and all outer scopes, down to the given outermost scope.
void InstantiatedLocal(const Decl *D, Decl *Inst)
void InstantiatedLocalPackArg(const Decl *D, VarDecl *Inst)
void MakeInstantiatedLocalArgPack(const Decl *D)
llvm::PointerUnion< Decl *, DeclArgumentPack * > * findInstantiationOf(const Decl *D)
Find the instantiation of the declaration D within the current instantiation scope.
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.
QualType getUnderlyingType() const
A pointer to member type per C++ 8.3.3 - Pointers to members.
QualType getPointeeType() const
Provides information a specialization of a member of a class template, which may be a member function...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
Describes a module or submodule.
Data structure that captures multiple levels of template argument lists for use in template instantia...
bool hasTemplateArgument(unsigned Depth, unsigned Index) const
Determine whether there is a non-NULL template argument at the given depth and index.
const ArgList & getInnermost() const
Retrieve the innermost template argument list.
std::pair< Decl *, bool > getAssociatedDecl(unsigned Depth) const
A template-like entity which owns the whole pattern being substituted.
unsigned getNumLevels() const
Determine the number of levels in this template argument list.
unsigned getNumSubstitutedLevels() const
Determine the number of substituted levels in this template argument list.
unsigned getNewDepth(unsigned OldDepth) const
Determine how many of the OldDepth outermost template parameter lists would be removed by substitutin...
void setArgument(unsigned Depth, unsigned Index, TemplateArgument Arg)
Clear out a specific template argument.
bool isRewrite() const
Determine whether we are rewriting template parameters rather than substituting for them.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given stream.
virtual void printName(raw_ostream &OS, const PrintingPolicy &Policy) const
Pretty-print the unqualified name of this declaration.
A C++ nested-name-specifier augmented with source location information.
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isInstantiationDependent() const
Whether this nested name specifier involves a template parameter.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
QualType getExpansionType(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
unsigned getDepth() const
Get the nesting depth of the template parameter.
Represents a pack expansion of types.
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Sugar for parentheses used when specifying types.
QualType getInnerType() const
Represents a parameter to a function.
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
void setDefaultArg(Expr *defarg)
SourceLocation getExplicitObjectParamThisLoc() const
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
void setUninstantiatedDefaultArg(Expr *arg)
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
bool hasUninstantiatedDefaultArg() const
bool hasInheritedDefaultArg() const
void setExplicitObjectParameterLoc(SourceLocation Loc)
Expr * getUninstantiatedDefaultArg()
unsigned getFunctionScopeDepth() const
void setHasInheritedDefaultArg(bool I=true)
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
[C99 6.4.2.2] - A predefined identifier such as func.
PredefinedIdentKind getIdentKind() const
SourceLocation getLocation() const
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
A (possibly-)qualified type.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
void addConst()
Add the const type qualifier to this QualType.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
The collection of all-type qualifiers we support.
void removeObjCLifetime()
Represents a struct/union/class.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeTypeAsWritten() const
Represents the body of a requires-expression.
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
RequiresExprBodyDecl * getBody() const
Scope - A scope is a transient data structure that is used while parsing the program.
RAII object used to change the argument pack substitution index within a Sema object.
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
For a defaulted function, the kind of defaulted function that it is.
DefaultedComparisonKind asComparison() const
bool isSpecialMember() const
CXXSpecialMember asSpecialMember() const
bool isComparison() const
A helper class for building up ExtParameterInfos.
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Sema - This implements semantic analysis and AST building for C.
llvm::DenseSet< Module * > LookupModulesCache
Cache of additional modules that should be used for name lookup within the current template instantia...
bool SubstTypeConstraint(TemplateTypeParmDecl *Inst, const TypeConstraint *TC, const MultiLevelTemplateArgumentList &TemplateArgs, bool EvaluateConstraint)
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD)
Determine the kind of defaulting that would be done for a given function.
bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, std::optional< unsigned > &NumExpansions)
Determine whether we could expand a pack expansion with the given set of parameter packs into separat...
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, std::optional< unsigned > NumExpansions, bool ExpectParameterPack, bool EvaluateConstraints=true)
void ActOnFinishCXXNonNestedClass()
NamedDecl * FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, bool FindingInstantiatedContext=false)
Find the instantiation of the given declaration within the current instantiation.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
void ActOnFinishDelayedMemberInitializers(Decl *Record)
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...
void InstantiateClassTemplateSpecializationMembers(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK)
Instantiate the definitions of all of the members of the given class template specialization,...
ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)
Returns the more specialized class template partial specialization according to the rules of partial ...
llvm::DenseSet< std::pair< Decl *, unsigned > > InstantiatingSpecializations
Specializations whose definitions are currently being instantiated.
void deduceOpenCLAddressSpace(ValueDecl *decl)
ExprResult SubstInitializer(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs, bool CXXDirectInit)
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
@ CTAK_Specified
The template argument was specified in the code or was instantiated with some deduced template argume...
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...
StmtResult SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs)
bool InNonInstantiationSFINAEContext
Whether we are in a SFINAE context that is not associated with template instantiation.
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
DiagnosticsEngine & getDiagnostics() const
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, std::optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
ExprResult BuildExpressionFromNonTypeTemplateArgument(const TemplateArgument &Arg, SourceLocation Loc)
ExprResult SubstConstraintExprWithoutSatisfaction(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
ASTContext & getASTContext() const
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.
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.
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool SubstTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentListInfo &Outputs)
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...
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
const LangOptions & getLangOpts() const
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
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 ...
void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD, bool ConstexprOnly=false)
MarkVirtualMembersReferenced - Will mark all members of the given CXXRecordDecl referenced.
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
DeclarationNameInfo SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, const MultiLevelTemplateArgumentList &TemplateArgs)
Do template substitution on declaration name info.
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
void PrintInstantiationStack()
Prints the current instantiation stack through a series of notes.
void popCodeSynthesisContext()
bool usesPartialOrExplicitSpecialization(SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec)
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
CXXBaseSpecifier * CheckBaseSpecifier(CXXRecordDecl *Class, SourceRange SpecifierRange, bool Virtual, AccessSpecifier Access, TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)
ActOnBaseSpecifier - Parsed a base specifier.
UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations
A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...
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...
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)
Check whether the given function decl's trailing requires clause is satisfied, if any.
bool CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind ActOnExplicitInstantiationNewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPtOfInstantiation, bool &SuppressNew)
Diagnose cases where we have an explicit template specialization before/after an explicit template in...
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
unsigned NonInstantiationEntries
The number of CodeSynthesisContexts that are not template instantiations and, therefore,...
bool CheckNoInlineAttr(const Stmt *OrigSt, const Stmt *CurSt, const AttributeCommonInfo &A)
bool CheckAlwaysInlineAttr(const Stmt *OrigSt, const Stmt *CurSt, const AttributeCommonInfo &A)
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, Expr *Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member,...
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed.
bool InstantiateInClassInitializer(SourceLocation PointOfInstantiation, FieldDecl *Instantiation, FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the definition of a field from the given pattern.
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.
bool CheckLoopHintExpr(Expr *E, SourceLocation Loc)
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
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.
bool SubstDefaultArgument(SourceLocation Loc, ParmVarDecl *Param, const MultiLevelTemplateArgumentList &TemplateArgs, bool ForCallExpr=false)
Substitute the given template arguments into the default argument.
ExprResult SubstConstraintExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
bool hasUncompilableErrorOccurred() const
Whether uncompilable error has occurred.
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
unsigned LastEmittedCodeSynthesisContextDepth
The depth of the context stack at the point when the most recent error or warning was produced.
bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, CheckTemplateArgumentKind CTAK)
Check that the given template argument corresponds to the given template parameter.
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record)
Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
DiagnosticsEngine & Diags
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier * > Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
SmallVector< Module *, 16 > CodeSynthesisContextLookupModules
Extra modules inspected when performing a lookup during a template instantiation.
ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)
Perform template argument deduction to determine whether the given template arguments match the given...
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
bool InstantiateEnum(SourceLocation PointOfInstantiation, EnumDecl *Instantiation, EnumDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiate the definition of an enum from a given pattern.
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments.
bool SubstTemplateArgument(const TemplateArgumentLoc &Input, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentLoc &Output)
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 warnStackExhausted(SourceLocation Loc)
Warn that the stack is nearly exhausted.
bool SubstBaseSpecifiers(CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Perform substitution on the base class specifiers of the given class template specialization.
void PerformDependentDiagnostics(const DeclContext *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
ASTMutationListener * getASTMutationListener() const
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
TypeSourceInfo * SubstFunctionDeclType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext, Qualifiers ThisTypeQuals, bool EvaluateConstraints=true)
A form of SubstType intended specifically for instantiating the type of a FunctionDecl.
Encodes a location in the source.
A trivial tuple used to represent a source range.
Represents a C++11 static_assert declaration.
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
Represents a reference to a non-type template parameter that has been substituted with a template arg...
std::optional< unsigned > getPackIndex() const
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
QualType getParameterType(const ASTContext &Ctx) const
Determine the substituted type of the template parameter.
NonTypeTemplateParmDecl * getParameter() const
Expr * getReplacement() const
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
SourceLocation getParameterPackLocation() const
Retrieve the location of the parameter pack name.
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
A structure for storing an already-substituted template template parameter pack.
Wrapper for substituted template type parameters.
Represents the result of substituting a set of types for a template type parameter pack.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
TemplateArgument getArgumentPack() const
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
Wrapper for substituted template type parameters.
Represents the declaration of a struct/union/class/enum.
void setTagKind(TagKind TK)
SourceRange getBraceRange() const
SourceLocation getInnerLocStart() const
Return SourceLocation representing start of source range ignoring outer template declarations.
StringRef getKindName() const
void startDefinition()
Starts the definition of this tag declaration.
TagKind getTagKind() const
void setBraceRange(SourceRange R)
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
A template argument list.
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Location wrapper for a TemplateArgument.
const TemplateArgument & getArgument() const
Represents a template argument.
ArrayRef< TemplateArgument > getPackAsArray() const
Return the array of arguments in this template argument pack.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
QualType getAsType() const
Retrieve the type for a type template argument.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
bool isNull() const
Determine whether this template argument has no value.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ Pack
The template argument is actually a parameter pack.
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
void enableLateAttributeInstantiation(Sema::LateInstantiatedAttrVec *LA)
void disableLateAttributeInstantiation()
delayed_var_partial_spec_iterator delayed_var_partial_spec_end()
delayed_partial_spec_iterator delayed_partial_spec_begin()
Return an iterator to the beginning of the set of "delayed" partial specializations,...
void setEvaluateConstraints(bool B)
SmallVectorImpl< std::pair< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > >::iterator delayed_var_partial_spec_iterator
LocalInstantiationScope * getStartingScope() const
VarTemplatePartialSpecializationDecl * InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a variable template partial specialization.
SmallVectorImpl< std::pair< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > >::iterator delayed_partial_spec_iterator
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
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...
delayed_var_partial_spec_iterator delayed_var_partial_spec_begin()
ClassTemplatePartialSpecializationDecl * InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl *ClassTemplate, ClassTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a class template partial specialization.
The base class of all kinds of template declarations (e.g., class, function, etc.).
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
bool isNull() const
Determine whether this template name is NULL.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
TemplateName getNameToSubstitute() const
Get the template name to substitute when this template name is used as a template template argument.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation getTemplateLoc() const
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
SourceLocation getLocation() const
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set.
Represents a type template specialization; the template must be a class template, a type alias templa...
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
unsigned getDepth() const
Get the nesting depth of the template parameter.
Declaration of a template type parameter.
bool isParameterPack() const
Returns whether this is a parameter pack.
void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)
Wrapper for template type parameters.
TemplateTypeParmDecl * getDecl() const
bool isParameterPack() const
unsigned getIndex() const
unsigned getDepth() const
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
ConceptDecl * getNamedConcept() const
Expr * getImmediatelyDeclaredConstraint() const
Get the immediately-declared constraint expression introduced by this type-constraint,...
const NestedNameSpecifierLoc & getNestedNameSpecifierLoc() const
const DeclarationNameInfo & getConceptNameInfo() const
ConceptReference * getConceptReference() const
void setLocStart(SourceLocation L)
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
void reserve(size_t Requested)
Ensures that this buffer has at least as much capacity as described.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
void pushTrivial(ASTContext &Context, QualType T, SourceLocation Loc)
Pushes 'T' with all locations pointing to 'Loc'.
Base wrapper for a particular "section" of type source info.
QualType getType() const
Get the type for which this source info wrapper provides information.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
TypeLoc IgnoreParens() const
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
unsigned getFullDataSize() const
Returns the size of the type source info data block.
SourceLocation getEndLoc() const
Get the end source location.
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
SourceLocation getNameLoc() const
void setNameLoc(SourceLocation Loc)
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
The base class of the type hierarchy.
bool isReferenceType() const
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
bool isStaticDataMember() const
Determines whether this is a static data member.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Declaration of a variable template.
Represents a variable template specialization, which refers to a variable template with a given set o...
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...
bool isClassScopeExplicitSpecialization() const
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
Represents a GCC generic vector type.
QualType getElementType() const
A requires-expression requirement which queries the validity and properties of an expression ('simple...
SubstitutionDiagnostic * getExprSubstitutionDiagnostic() const
bool isExprSubstitutionFailure() const
const ReturnTypeRequirement & getReturnTypeRequirement() const
SourceLocation getNoexceptLoc() const
A requires-expression requirement which is satisfied when a general constraint expression is satisfie...
const ASTConstraintSatisfaction & getConstraintSatisfaction() const
bool hasInvalidConstraint() const
Expr * getConstraintExpr() const
StringRef getInvalidConstraintEntity()
A static requirement that can be used in a requires-expression to check properties of types and expre...
A requires-expression requirement which queries the existence of a type name or type template special...
bool isSubstitutionFailure() const
SubstitutionDiagnostic * getSubstitutionDiagnostic() const
TypeSourceInfo * getType() const
Provides information about an attempted template argument deduction, whose success or failure was des...
TemplateArgumentList * takeCanonical()
SourceLocation getLocation() const
Returns the location at which template argument is occurring.
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
Defines the clang::TargetInfo interface.
Requirement::SubstitutionDiagnostic * createSubstDiagAt(Sema &S, SourceLocation Location, EntityPrinter Printer)
create a Requirement::SubstitutionDiagnostic with only a SubstitutedEntity and DiagLoc using Sema's a...
llvm::function_ref< void(llvm::raw_ostream &)> EntityPrinter
Attr * instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
Attr * instantiateTemplateAttributeForDecl(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
The JSON file list parser is used to communicate input to InstallAPI.
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
NamedDecl * getAsNamedDecl(TemplateParameter P)
bool isStackNearlyExhausted()
Determine whether the stack is nearly exhausted.
bool isGenericLambdaCallOperatorOrStaticInvokerSpecialization(const DeclContext *DC)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
TagTypeKind
The kind of a tag type.
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema's representation of template deduction information to the form used in overload-can...
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
std::pair< unsigned, unsigned > getDepthAndIndex(NamedDecl *ND)
Retrieve the depth and index of a template parameter.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
TemplateDeductionResult
Describes the result of template argument deduction.
@ Success
Template argument deduction was successful.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ None
No keyword precedes the qualified type name.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
@ EST_Uninstantiated
not instantiated yet
@ EST_None
no exception specification
__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
SourceLocation RAngleLoc
The source location of the right angle bracket ('>').
SourceLocation LAngleLoc
The source location of the left angle bracket ('<').
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
Holds information about the various types of exception specification.
ExceptionSpecificationType Type
The kind of exception specification this is.
ExceptionSpecInfo ExceptionSpec
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
SourceRange InstantiationRange
The source range that covers the construct that cause the instantiation, e.g., the template-id that c...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
bool SavedInNonInstantiationSFINAEContext
Was the enclosing context a non-instantiation SFINAE context?
const TemplateArgument * TemplateArgs
The list of template arguments we are substituting, if they are not part of the entity.
sema::TemplateDeductionInfo * DeductionInfo
The template deduction info object associated with the substitution or checking of explicit or deduce...
NamedDecl * Template
The template (or partial specialization) in which we are performing the instantiation,...
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
SynthesisKind
The kind of template instantiation we are performing.
@ MarkingClassDllexported
We are marking a class as __dllexport.
@ RequirementParameterInstantiation
@ DefaultTemplateArgumentInstantiation
We are instantiating a default argument for a template parameter.
@ ExplicitTemplateArgumentSubstitution
We are substituting explicit template arguments provided for a function template.
@ DefaultTemplateArgumentChecking
We are checking the validity of a default template argument that has been used when naming a template...
@ InitializingStructuredBinding
We are initializing a structured binding.
@ ExceptionSpecInstantiation
We are instantiating the exception specification for a function template which was deferred until it ...
@ NestedRequirementConstraintsCheck
We are checking the satisfaction of a nested requirement of a requires expression.
@ BuildingBuiltinDumpStructCall
We are building an implied call from __builtin_dump_struct.
@ ParameterMappingSubstitution
@ DefiningSynthesizedFunction
We are defining a synthesized function (such as a defaulted special member).
@ Memoization
Added for Template instantiation observation.
@ ConstraintNormalization
@ LambdaExpressionSubstitution
We are substituting into a lambda expression.
@ BuildingDeductionGuides
We are building deduction guides for a class.
@ DeducedTemplateArgumentSubstitution
We are substituting template argument determined as part of template argument deduction for either a ...
@ PriorTemplateArgumentSubstitution
We are substituting prior template arguments into a new template parameter.
@ ExceptionSpecEvaluation
We are computing the exception specification for a defaulted special member function.
@ TemplateInstantiation
We are instantiating a template declaration.
@ DeclaringSpecialMember
We are declaring an implicit special member function.
@ DeclaringImplicitEqualityComparison
We are declaring an implicit 'operator==' for a defaulted 'operator<=>'.
@ DefaultFunctionArgumentInstantiation
We are instantiating a default argument for a function.
@ RewritingOperatorAsSpaceship
We are rewriting a comparison operator in terms of an operator<=>.
@ RequirementInstantiation
We are instantiating a requirement of a requires expression.
Decl * Entity
The entity that is being synthesized.
bool isInstantiationRecord() const
Determines whether this template is an actual instantiation that should be counted toward the maximum...
A stack object to be created when performing template instantiation.
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity, SourceRange InstantiationRange=SourceRange())
Note that we are instantiating a class template, function template, variable template,...
void Clear()
Note that we have finished instantiating this template.
bool isAlreadyInstantiating() const
Determine whether we are already instantiating this specialization in some surrounding active instant...
void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)