38#include "llvm/ADT/STLForwardCompat.h"
39#include "llvm/ADT/StringExtras.h"
40#include "llvm/Support/ErrorHandling.h"
41#include "llvm/Support/SaveAndRestore.h"
42#include "llvm/Support/TimeProfiler.h"
55 const Decl *NextDecl =
nullptr;
57 bool ClearRelativeToPrimary =
true;
58 static Response Done() {
63 static Response ChangeDecl(
const Decl *ND) {
68 static Response ChangeDecl(
const DeclContext *Ctx) {
74 static Response UseNextDecl(
const Decl *CurDecl) {
78 static Response DontClearRelativeToPrimaryNextDecl(
const Decl *CurDecl) {
79 Response R = Response::UseNextDecl(CurDecl);
80 R.ClearRelativeToPrimary =
false;
89getPrimaryTemplateOfGenericLambda(
const FunctionDecl *LambdaCallOperator) {
91 return LambdaCallOperator;
93 if (
auto *FTD = dyn_cast_if_present<FunctionTemplateDecl>(
95 FTD && FTD->getInstantiatedFromMemberTemplate()) {
97 FTD->getInstantiatedFromMemberTemplate()->getTemplatedDecl();
103 }
else if (
auto *Prev = cast<CXXMethodDecl>(LambdaCallOperator)
104 ->getInstantiatedFromMemberFunction())
105 LambdaCallOperator = Prev;
109 return LambdaCallOperator;
112struct EnclosingTypeAliasTemplateDetails {
117 explicit operator bool()
noexcept {
return Template; }
122EnclosingTypeAliasTemplateDetails
123getEnclosingTypeAliasTemplateDecl(
Sema &SemaRef) {
126 TypeAliasTemplateInstantiation)
128 EnclosingTypeAliasTemplateDetails Result;
129 auto *TATD = cast<TypeAliasTemplateDecl>(CSC.Entity),
130 *Next = TATD->getInstantiatedFromMemberTemplate();
134 CSC.template_arguments(),
137 Result.PrimaryTypeAliasDecl = Next;
138 Next = Next->getInstantiatedFromMemberTemplate();
151bool isLambdaEnclosedByTypeAliasDecl(
155 Visitor(
const FunctionDecl *CallOperator) : CallOperator(CallOperator) {}
156 bool VisitLambdaExpr(
LambdaExpr *LE)
override {
159 return getPrimaryTemplateOfGenericLambda(LE->getCallOperator()) !=
168 return !Visitor(getPrimaryTemplateOfGenericLambda(LambdaCallOperator))
169 .TraverseType(Underlying);
176 bool SkipForSpecialization) {
180 return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);
184 !isa<VarTemplatePartialSpecializationDecl>(VarTemplSpec))
185 return Response::Done();
190 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
194 if (!SkipForSpecialization)
195 Result.addOuterTemplateArguments(
198 if (Partial->isMemberSpecialization())
199 return Response::Done();
202 if (!SkipForSpecialization)
203 Result.addOuterTemplateArguments(
207 return Response::Done();
209 return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);
221 for (
unsigned I = 0, N = TTP->
getDepth() + 1; I != N; ++I)
222 Result.addOuterTemplateArguments(std::nullopt);
223 return Response::Done();
226Response HandlePartialClassTemplateSpec(
229 if (!SkipForSpecialization)
231 return Response::Done();
238 bool SkipForSpecialization) {
242 !isa<ClassTemplatePartialSpecializationDecl>(ClassTemplSpec))
243 return Response::Done();
245 if (!SkipForSpecialization)
246 Result.addOuterTemplateArguments(
255 return Response::Done();
261 if (
auto *InstFromPartialTempl =
264 return Response::ChangeDecl(
265 InstFromPartialTempl->getLexicalDeclContext());
267 return Response::UseNextDecl(ClassTemplSpec);
273 bool ForConstraintInstantiation,
274 bool ForDefaultArgumentSubstitution) {
276 if (!RelativeToPrimary &&
277 Function->getTemplateSpecializationKindForInstantiation() ==
279 return Response::Done();
281 if (!RelativeToPrimary &&
286 return Response::UseNextDecl(
Function);
288 Function->getTemplateSpecializationArgs()) {
291 TemplateArgs->asArray(),
294 if (RelativeToPrimary &&
295 (
Function->getTemplateSpecializationKind() ==
298 !
Function->getPrimaryTemplate()->getFriendObjectKind())))
299 return Response::UseNextDecl(
Function);
303 assert(
Function->getPrimaryTemplate() &&
"No function template?");
304 if (!ForDefaultArgumentSubstitution &&
305 Function->getPrimaryTemplate()->isMemberSpecialization())
306 return Response::Done();
309 if (!ForConstraintInstantiation &&
311 return Response::Done();
313 }
else if (
Function->getDescribedFunctionTemplate()) {
315 (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
316 "Outer template not instantiated?");
323 Function->getNonTransparentDeclContext()->isFileContext() &&
325 return Response::ChangeDecl(
Function->getLexicalDeclContext());
328 if (ForConstraintInstantiation &&
Function->getFriendObjectKind())
329 return Response::ChangeDecl(
Function->getLexicalDeclContext());
330 return Response::UseNextDecl(
Function);
333Response HandleFunctionTemplateDecl(
Sema &SemaRef,
336 if (!isa<ClassTemplateSpecializationDecl>(FTD->
getDeclContext())) {
337 Result.addOuterTemplateArguments(
366 if (TSTy->isCurrentInstantiation()) {
367 auto *RD = TSTy->getCanonicalTypeInternal()->getAsCXXRecordDecl();
369 Arguments = CTD->getInjectedTemplateArgs(SemaRef.
Context);
371 dyn_cast<ClassTemplateSpecializationDecl>(RD))
375 Result.addOuterTemplateArguments(
376 TSTy->getTemplateName().getAsTemplateDecl(), Arguments,
391 bool ForConstraintInstantiation) {
394 (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
395 "Outer template not instantiated?");
396 if (ClassTemplate->isMemberSpecialization())
397 return Response::Done();
398 if (ForConstraintInstantiation)
399 Result.addOuterTemplateArguments(
401 ClassTemplate->getInjectedTemplateArgs(SemaRef.
Context),
408 return Response::Done();
413 if (ForConstraintInstantiation && IsFriend &&
422 return Response::ChangeDecl(LCD);
426 if (
auto TypeAlias = getEnclosingTypeAliasTemplateDecl(SemaRef);
427 ForConstraintInstantiation && TypeAlias) {
429 TypeAlias.PrimaryTypeAliasDecl)) {
430 Result.addOuterTemplateArguments(TypeAlias.Template,
431 TypeAlias.AssociatedTemplateArguments,
446 return Response::ChangeDecl(TypeAlias.Template->getDeclContext());
451 return Response::UseNextDecl(Rec);
454Response HandleImplicitConceptSpecializationDecl(
457 Result.addOuterTemplateArguments(
461 return Response::UseNextDecl(CSD);
464Response HandleGenericDeclContext(
const Decl *CurDecl) {
465 return Response::UseNextDecl(CurDecl);
473 const FunctionDecl *Pattern,
bool ForConstraintInstantiation,
474 bool SkipForSpecialization,
bool ForDefaultArgumentSubstitution) {
475 assert((ND || DC) &&
"Can't find arguments for a decl if one isn't provided");
480 const Decl *CurDecl = ND;
486 Result.addOuterTemplateArguments(
const_cast<NamedDecl *
>(ND), *Innermost,
496 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl))
497 HandleDefaultTempArgIntoTempTempParam(TTP,
Result);
498 CurDecl = Response::UseNextDecl(CurDecl).NextDecl;
503 if (
const auto *VarTemplSpec =
504 dyn_cast<VarTemplateSpecializationDecl>(CurDecl)) {
505 R = HandleVarTemplateSpec(VarTemplSpec,
Result, SkipForSpecialization);
506 }
else if (
const auto *PartialClassTemplSpec =
507 dyn_cast<ClassTemplatePartialSpecializationDecl>(CurDecl)) {
508 R = HandlePartialClassTemplateSpec(PartialClassTemplSpec,
Result,
509 SkipForSpecialization);
510 }
else if (
const auto *ClassTemplSpec =
511 dyn_cast<ClassTemplateSpecializationDecl>(CurDecl)) {
512 R = HandleClassTemplateSpec(ClassTemplSpec,
Result,
513 SkipForSpecialization);
514 }
else if (
const auto *
Function = dyn_cast<FunctionDecl>(CurDecl)) {
515 R = HandleFunction(*
this,
Function,
Result, Pattern, RelativeToPrimary,
516 ForConstraintInstantiation,
517 ForDefaultArgumentSubstitution);
518 }
else if (
const auto *Rec = dyn_cast<CXXRecordDecl>(CurDecl)) {
520 ForConstraintInstantiation);
521 }
else if (
const auto *CSD =
522 dyn_cast<ImplicitConceptSpecializationDecl>(CurDecl)) {
523 R = HandleImplicitConceptSpecializationDecl(CSD,
Result);
524 }
else if (
const auto *FTD = dyn_cast<FunctionTemplateDecl>(CurDecl)) {
525 R = HandleFunctionTemplateDecl(*
this, FTD,
Result);
526 }
else if (
const auto *CTD = dyn_cast<ClassTemplateDecl>(CurDecl)) {
527 R = Response::ChangeDecl(CTD->getLexicalDeclContext());
528 }
else if (!isa<DeclContext>(CurDecl)) {
529 R = Response::DontClearRelativeToPrimaryNextDecl(CurDecl);
530 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl)) {
531 R = HandleDefaultTempArgIntoTempTempParam(TTP,
Result);
534 R = HandleGenericDeclContext(CurDecl);
539 if (R.ClearRelativeToPrimary)
540 RelativeToPrimary =
false;
542 CurDecl = R.NextDecl;
586 llvm_unreachable(
"Invalid SynthesisKind!");
616 AlreadyInstantiating = !Inst.Entity ?
false :
618 .insert({Inst.Entity->getCanonicalDecl(), Inst.Kind})
629 PointOfInstantiation, InstantiationRange, Entity) {}
636 PointOfInstantiation, InstantiationRange, Entity) {}
646 Template, TemplateArgs) {}
656 TemplateArgs, &DeductionInfo) {
670 PointOfInstantiation, InstantiationRange, Template, nullptr,
671 TemplateArgs, &DeductionInfo) {}
681 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
682 TemplateArgs, &DeductionInfo) {}
692 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
693 TemplateArgs, &DeductionInfo) {}
701 PointOfInstantiation, InstantiationRange, Param, nullptr,
711 PointOfInstantiation, InstantiationRange, Param, Template,
721 PointOfInstantiation, InstantiationRange, Param, Template,
730 PointOfInstantiation, InstantiationRange, Entity,
731 nullptr, TemplateArgs) {}
739 PointOfInstantiation, InstantiationRange, Param, Template,
748 PointOfInstantiation, InstantiationRange, nullptr,
749 nullptr, {}, &DeductionInfo) {}
757 PointOfInstantiation, InstantiationRange, nullptr,
765 PointOfInstantiation, InstantiationRange, nullptr,
766 nullptr, {}, &DeductionInfo) {}
774 PointOfInstantiation, InstantiationRange, Template, nullptr,
783 PointOfInstantiation, InstantiationRange, Template, nullptr,
784 {}, &DeductionInfo) {}
792 PointOfInstantiation, InstantiationRange, Template) {}
800 PointOfInstantiation, InstantiationRange, Template) {}
807 PointOfInstantiation, InstantiationRange, Entity) {}
813 ArgLoc, InstantiationRange, PArg) {}
821 if (!Ctx.isInstantiationRecord())
831 if (!Active.isInstantiationRecord()) {
841 "forgot to remove a lookup module for a template instantiation");
860 if (!AlreadyInstantiating) {
864 {Active.Entity->getCanonicalDecl(), Active.Kind});
878 llvm::raw_string_ostream
OS(
Result);
879 llvm::ListSeparator Comma;
880 for (
const Expr *Arg : Args) {
882 Arg->IgnoreParens()->printPretty(
OS,
nullptr,
888bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
899 diag::err_template_recursion_depth_exceeded)
901 << InstantiationRange;
902 SemaRef.
Diag(PointOfInstantiation, diag::note_template_recursion_depth)
912 SkipStart = Limit / 2 + Limit % 2;
917 unsigned InstantiationIdx = 0;
922 ++Active, ++InstantiationIdx) {
924 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
925 if (InstantiationIdx == SkipStart) {
928 diag::note_instantiation_contexts_suppressed)
934 switch (Active->Kind) {
936 Decl *
D = Active->Entity;
938 unsigned DiagID = diag::note_template_member_class_here;
939 if (isa<ClassTemplateSpecializationDecl>(
Record))
940 DiagID = diag::note_template_class_instantiation_here;
942 <<
Record << Active->InstantiationRange;
946 DiagID = diag::note_function_template_spec_here;
948 DiagID = diag::note_template_member_function_here;
951 << Active->InstantiationRange;
952 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(
D)) {
954 VD->isStaticDataMember()?
955 diag::note_template_static_data_member_def_here
956 : diag::note_template_variable_def_here)
958 << Active->InstantiationRange;
959 }
else if (
EnumDecl *ED = dyn_cast<EnumDecl>(
D)) {
961 diag::note_template_enum_def_here)
963 << Active->InstantiationRange;
964 }
else if (
FieldDecl *FD = dyn_cast<FieldDecl>(
D)) {
966 diag::note_template_nsdmi_here)
967 << FD << Active->InstantiationRange;
970 diag::note_template_class_instantiation_here)
971 << CTD << Active->InstantiationRange;
977 TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
979 llvm::raw_svector_ostream
OS(TemplateArgsStr);
984 diag::note_default_arg_instantiation_here)
986 << Active->InstantiationRange;
993 diag::note_explicit_template_arg_substitution_here)
996 Active->TemplateArgs,
997 Active->NumTemplateArgs)
998 << Active->InstantiationRange;
1004 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
1006 diag::note_function_template_deduction_instantiation_here)
1009 Active->TemplateArgs,
1010 Active->NumTemplateArgs)
1011 << Active->InstantiationRange;
1013 bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
1014 isa<VarTemplateSpecializationDecl>(Active->Entity);
1015 bool IsTemplate =
false;
1017 if (
auto *
D = dyn_cast<TemplateDecl>(Active->Entity)) {
1019 Params =
D->getTemplateParameters();
1020 }
else if (
auto *
D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
1022 Params =
D->getTemplateParameters();
1023 }
else if (
auto *
D = dyn_cast<VarTemplatePartialSpecializationDecl>(
1025 Params =
D->getTemplateParameters();
1027 llvm_unreachable(
"unexpected template kind");
1031 diag::note_deduced_template_arg_substitution_here)
1032 << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
1034 Active->NumTemplateArgs)
1035 << Active->InstantiationRange;
1041 ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
1045 llvm::raw_svector_ostream
OS(TemplateArgsStr);
1050 diag::note_default_function_arg_instantiation_here)
1052 << Active->InstantiationRange;
1057 NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
1060 Name = std::string(
" '") + Parm->
getName().str() +
"'";
1063 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
1064 TemplateParams = Template->getTemplateParameters();
1067 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
1068 ->getTemplateParameters();
1070 diag::note_prior_template_arg_substitution)
1071 << isa<TemplateTemplateParmDecl>(Parm)
1074 Active->TemplateArgs,
1075 Active->NumTemplateArgs)
1076 << Active->InstantiationRange;
1082 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
1083 TemplateParams = Template->getTemplateParameters();
1086 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
1087 ->getTemplateParameters();
1090 diag::note_template_default_arg_checking)
1092 Active->TemplateArgs,
1093 Active->NumTemplateArgs)
1094 << Active->InstantiationRange;
1100 diag::note_evaluating_exception_spec_here)
1101 << cast<FunctionDecl>(Active->Entity);
1106 diag::note_template_exception_spec_instantiation_here)
1107 << cast<FunctionDecl>(Active->Entity)
1108 << Active->InstantiationRange;
1113 diag::note_template_requirement_instantiation_here)
1114 << Active->InstantiationRange;
1118 diag::note_template_requirement_params_instantiation_here)
1119 << Active->InstantiationRange;
1124 diag::note_nested_requirement_here)
1125 << Active->InstantiationRange;
1130 diag::note_in_declaration_of_implicit_special_member)
1131 << cast<CXXRecordDecl>(Active->Entity)
1132 << llvm::to_underlying(Active->SpecialMember);
1137 diag::note_in_declaration_of_implicit_equality_comparison);
1143 auto *FD = dyn_cast<FunctionDecl>(Active->Entity);
1147 auto *MD = cast<CXXMethodDecl>(FD);
1149 diag::note_member_synthesized_at)
1150 << MD->isExplicitlyDefaulted()
1156 .getNonReferenceType()
1157 .getUnqualifiedType();
1159 diag::note_comparison_synthesized_at)
1167 diag::note_rewriting_operator_as_spaceship);
1172 diag::note_in_binding_decl_init)
1173 << cast<BindingDecl>(Active->Entity);
1178 diag::note_due_to_dllexported_class)
1179 << cast<CXXRecordDecl>(Active->Entity) << !
getLangOpts().CPlusPlus11;
1184 diag::note_building_builtin_dump_struct_call)
1194 diag::note_lambda_substitution_here);
1197 unsigned DiagID = 0;
1198 if (!Active->Entity) {
1200 diag::note_nested_requirement_here)
1201 << Active->InstantiationRange;
1204 if (isa<ConceptDecl>(Active->Entity))
1205 DiagID = diag::note_concept_specialization_here;
1206 else if (isa<TemplateDecl>(Active->Entity))
1207 DiagID = diag::note_checking_constraints_for_template_id_here;
1208 else if (isa<VarTemplatePartialSpecializationDecl>(Active->Entity))
1209 DiagID = diag::note_checking_constraints_for_var_spec_id_here;
1210 else if (isa<ClassTemplatePartialSpecializationDecl>(Active->Entity))
1211 DiagID = diag::note_checking_constraints_for_class_spec_id_here;
1213 assert(isa<FunctionDecl>(Active->Entity));
1214 DiagID = diag::note_checking_constraints_for_function_here;
1217 llvm::raw_svector_ostream
OS(TemplateArgsStr);
1219 if (!isa<FunctionDecl>(Active->Entity)) {
1223 Diags.
Report(Active->PointOfInstantiation, DiagID) <<
OS.str()
1224 << Active->InstantiationRange;
1229 diag::note_constraint_substitution_here)
1230 << Active->InstantiationRange;
1234 diag::note_constraint_normalization_here)
1235 << cast<NamedDecl>(Active->Entity) << Active->InstantiationRange;
1239 diag::note_parameter_mapping_substitution_here)
1240 << Active->InstantiationRange;
1244 diag::note_building_deduction_guide_here);
1248 diag::note_template_type_alias_instantiation_here)
1249 << cast<TypeAliasTemplateDecl>(Active->Entity)
1250 << Active->InstantiationRange;
1254 diag::note_template_arg_template_params_mismatch);
1257 Diags.
Report(ParamLoc, diag::note_template_prev_declaration)
1258 <<
true << Active->InstantiationRange;
1266 return std::optional<TemplateDeductionInfo *>(
nullptr);
1271 Active != ActiveEnd;
1274 switch (Active->Kind) {
1278 if (isa<TypeAliasTemplateDecl>(Active->Entity))
1289 return std::nullopt;
1296 return std::nullopt;
1318 assert(Active->DeductionInfo &&
"Missing deduction info pointer");
1319 return Active->DeductionInfo;
1330 return std::nullopt;
1344 if (Active->SavedInNonInstantiationSFINAEContext)
1345 return std::optional<TemplateDeductionInfo *>(
nullptr);
1348 return std::nullopt;
1355 class TemplateInstantiator :
public TreeTransform<TemplateInstantiator> {
1360 bool EvaluateConstraints =
true;
1363 bool IsIncomplete =
false;
1365 bool BailOutOnIncomplete;
1370 TemplateInstantiator(
Sema &SemaRef,
1373 bool BailOutOnIncomplete =
false)
1374 : inherited(SemaRef), TemplateArgs(TemplateArgs),
Loc(
Loc),
1375 Entity(Entity), BailOutOnIncomplete(BailOutOnIncomplete) {}
1377 void setEvaluateConstraints(
bool B) {
1378 EvaluateConstraints = B;
1380 bool getEvaluateConstraints() {
1381 return EvaluateConstraints;
1398 bool getIsIncomplete()
const {
return IsIncomplete; }
1404 this->Entity = Entity;
1407 unsigned TransformTemplateDepth(
unsigned Depth) {
1412 int Index = getSema().ArgumentPackSubstitutionIndex;
1414 return std::nullopt;
1421 bool &ShouldExpand,
bool &RetainExpansion,
1422 std::optional<unsigned> &NumExpansions) {
1423 return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
1424 PatternRange, Unexpanded,
1431 void ExpandingFunctionParameterPack(
ParmVarDecl *Pack) {
1441 unsigned Depth, Index;
1444 Result = TemplateArgs(Depth, Index);
1447 IsIncomplete =
true;
1448 if (BailOutOnIncomplete)
1464 unsigned Depth, Index;
1474 void transformAttrs(
Decl *Old,
Decl *New) {
1480 (NewDecls.size() != 1 || !NewDecls.front()->isParameterPack())) {
1482 for (
auto *New : NewDecls)
1484 Old, cast<VarDecl>(New));
1488 assert(NewDecls.size() == 1 &&
1489 "should only have multiple expansions for a pack");
1490 Decl *New = NewDecls.front();
1495 auto *NewMD = dyn_cast<CXXMethodDecl>(New);
1497 auto *OldMD = dyn_cast<CXXMethodDecl>(Old);
1498 if (
auto *NewTD = NewMD->getDescribedFunctionTemplate())
1499 NewTD->setInstantiatedFromMemberTemplate(
1500 OldMD->getDescribedFunctionTemplate());
1502 NewMD->setInstantiationOfMemberFunction(OldMD,
1510 if (
auto *DC = dyn_cast<DeclContext>(Old);
1511 DC && DC->isDependentContext() && DC->isFunctionOrMethod())
1552 NamedDecl *FirstQualifierInScope =
nullptr,
1553 bool AllowInjectedClassName =
false);
1555 const AnnotateAttr *TransformAnnotateAttr(
const AnnotateAttr *AA);
1556 const CXXAssumeAttr *TransformCXXAssumeAttr(
const CXXAssumeAttr *AA);
1557 const LoopHintAttr *TransformLoopHintAttr(
const LoopHintAttr *LH);
1558 const NoInlineAttr *TransformStmtNoInlineAttr(
const Stmt *OrigS,
1560 const NoInlineAttr *A);
1561 const AlwaysInlineAttr *
1562 TransformStmtAlwaysInlineAttr(
const Stmt *OrigS,
const Stmt *InstS,
1563 const AlwaysInlineAttr *A);
1564 const CodeAlignAttr *TransformCodeAlignAttr(
const CodeAlignAttr *CA);
1571 ExprResult TransformSubstNonTypeTemplateParmPackExpr(
1573 ExprResult TransformSubstNonTypeTemplateParmExpr(
1590 return inherited::TransformFunctionProtoType(TLB, TL);
1595 auto Type = inherited::TransformInjectedClassNameType(TLB, TL);
1598 if (
Type.isNull() &&
1605 inherited::TransformType(ICT->getInjectedSpecializationType());
1616 bool Uneval =
false) {
1618 std::vector<TemplateArgument> TArgs;
1638 return inherited::TransformTemplateArgument(Input, Output, Uneval);
1641 template<
typename Fn>
1646 Fn TransformExceptionSpec);
1649 TransformFunctionTypeParam(
ParmVarDecl *OldParm,
int indexAdjustment,
1650 std::optional<unsigned> NumExpansions,
1651 bool ExpectParameterPack);
1653 using inherited::TransformTemplateTypeParmType;
1658 bool SuppressObjCLifetime);
1660 QualType BuildSubstTemplateTypeParmType(
1662 Decl *AssociatedDecl,
unsigned Index, std::optional<unsigned> PackIndex,
1668 using inherited::TransformSubstTemplateTypeParmPackType;
1672 bool SuppressObjCLifetime);
1678 if (
Type->getSubstitutionFlag() !=
1679 SubstTemplateTypeParmTypeFlag::ExpandPacksInPlace)
1680 return inherited::TransformSubstTemplateTypeParmType(TLB, TL);
1682 assert(
Type->getPackIndex());
1684 Type->getReplacedParameter()->getDepth(),
Type->getIndex());
1689 return inherited::TransformSubstTemplateTypeParmType(TLB, TL);
1694 if (
auto TypeAlias =
1695 TemplateInstArgsHelpers::getEnclosingTypeAliasTemplateDecl(
1697 TypeAlias && TemplateInstArgsHelpers::isLambdaEnclosedByTypeAliasDecl(
1699 unsigned TypeAliasDeclDepth =
TypeAlias.Template->getTemplateDepth();
1701 return CXXRecordDecl::LambdaDependencyKind::LDK_AlwaysDependent;
1704 return CXXRecordDecl::LambdaDependencyKind::LDK_AlwaysDependent;
1706 return inherited::ComputeLambdaDependency(LSI);
1718 return inherited::TransformLambdaExpr(
E);
1724 return inherited::TransformBlockExpr(
E);
1731 assert(PVD &&
"null in a parameter list");
1732 if (!PVD->hasDefaultArg())
1734 Expr *UninstExpr = PVD->getUninstantiatedDefaultArg();
1745 PVD->setDefaultArg(ErrorResult.
get());
1748 return inherited::RebuildLambdaExpr(StartLoc, EndLoc, LSI);
1762 return inherited::TransformLambdaBody(
E, Body);
1767 ExprResult TransReq = inherited::TransformRequiresExpr(
E);
1770 assert(TransReq.
get() !=
E &&
1771 "Do not change value of isSatisfied for the existing expression. "
1772 "Create a new expression instead.");
1773 if (
E->getBody()->isDependentContext()) {
1779 if (Trap.hasErrorOccurred())
1785 bool TransformRequiresExprRequirements(
1788 bool SatisfactionDetermined =
false;
1791 if (!SatisfactionDetermined) {
1792 if (
auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req))
1793 TransReq = TransformTypeRequirement(TypeReq);
1794 else if (
auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req))
1795 TransReq = TransformExprRequirement(ExprReq);
1797 TransReq = TransformNestedRequirement(
1798 cast<concepts::NestedRequirement>(Req));
1807 SatisfactionDetermined =
true;
1810 Transformed.push_back(TransReq);
1817 if (!OrigTPL || !OrigTPL->
size())
return OrigTPL;
1821 Owner, TemplateArgs);
1822 DeclInstantiator.setEvaluateConstraints(EvaluateConstraints);
1823 return DeclInstantiator.SubstTemplateParams(OrigTPL);
1841 transformNonTypeTemplateParmRef(
Decl *AssociatedDecl,
1844 std::optional<unsigned> PackIndex);
1848bool TemplateInstantiator::AlreadyTransformed(
QualType T) {
1855 getSema().MarkDeclarationsReferencedInType(
Loc,
T);
1880 TTP->getPosition())) {
1881 IsIncomplete =
true;
1882 return BailOutOnIncomplete ? nullptr :
D;
1887 if (TTP->isParameterPack()) {
1889 "Missing argument pack");
1895 "Wrong kind of template template argument");
1907 Decl *Inst = getSema().SubstDecl(
D, getSema().
CurContext, TemplateArgs);
1911 getSema().CurrentInstantiationScope->InstantiatedLocal(
D, Inst);
1915bool TemplateInstantiator::TransformExceptionSpec(
1922 return inherited::TransformExceptionSpec(
Loc, ESI, Exceptions, Changed);
1926TemplateInstantiator::TransformFirstQualifierInScope(
NamedDecl *
D,
1940 "Missing argument pack");
1950 return cast_or_null<NamedDecl>(TransformDecl(
Loc,
D));
1953 return Tag->getDecl();
1956 getSema().Diag(
Loc, diag::err_nested_name_spec_non_tag) <<
T;
1961 return cast_or_null<NamedDecl>(TransformDecl(
Loc,
D));
1965TemplateInstantiator::RebuildExceptionDecl(
VarDecl *ExceptionDecl,
1971 StartLoc, NameLoc, Name);
1973 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1977VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(
VarDecl *ExceptionDecl,
1980 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo,
T);
1982 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1987TemplateInstantiator::RebuildElaboratedType(
SourceLocation KeywordLoc,
2005 SemaRef.
Diag(TagLocation, diag::err_use_with_wrong_tag)
2014 return inherited::RebuildElaboratedType(KeywordLoc, Keyword, QualifierLoc,
T);
2017TemplateName TemplateInstantiator::TransformTemplateName(
2020 bool AllowInjectedClassName) {
2022 = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {
2029 TTP->getPosition())) {
2030 IsIncomplete =
true;
2041 "unexpected pack arguments in template rewrite");
2045 "unexpected nontype template argument kind in template rewrite");
2049 auto [AssociatedDecl, Final] =
2051 std::optional<unsigned> PackIndex;
2054 "Missing argument pack");
2060 return getSema().Context.getSubstTemplateTemplateParmPack(
2061 Arg, AssociatedDecl, TTP->
getIndex(), Final);
2064 PackIndex = getPackIndex(Arg);
2069 assert(!Template.
isNull() &&
"Null template template argument");
2073 return getSema().Context.getSubstTemplateTemplateParm(
2074 Template, AssociatedDecl, TTP->
getIndex(), PackIndex);
2079 = Name.getAsSubstTemplateTemplateParmPack()) {
2086 if (SubstPack->getFinal())
2088 return getSema().Context.getSubstTemplateTemplateParm(
2089 Template, SubstPack->getAssociatedDecl(), SubstPack->getIndex(),
2090 getPackIndex(Pack));
2093 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
2094 FirstQualifierInScope,
2095 AllowInjectedClassName);
2103 return getSema().BuildPredefinedExpr(
E->getLocation(),
E->getIdentKind());
2107TemplateInstantiator::TransformTemplateParmRefExpr(
DeclRefExpr *
E,
2115 IsIncomplete =
true;
2116 return BailOutOnIncomplete ?
ExprError() :
E;
2126 "unexpected pack arguments in template rewrite");
2130 "unexpected nontype template argument kind in template rewrite");
2137 std::optional<unsigned> PackIndex;
2140 "Missing argument pack");
2158 E->getLocation(), Arg, AssociatedDecl, NTTP->
getPosition());
2160 PackIndex = getPackIndex(Arg);
2164 return transformNonTypeTemplateParmRef(AssociatedDecl, NTTP,
E->getLocation(),
2169TemplateInstantiator::TransformAnnotateAttr(
const AnnotateAttr *AA) {
2171 for (
Expr *Arg : AA->args()) {
2172 ExprResult Res = getDerived().TransformExpr(Arg);
2174 Args.push_back(Res.
get());
2176 return AnnotateAttr::CreateImplicit(getSema().
Context, AA->getAnnotation(),
2177 Args.data(), Args.size(), AA->getRange());
2180const CXXAssumeAttr *
2181TemplateInstantiator::TransformCXXAssumeAttr(
const CXXAssumeAttr *AA) {
2182 ExprResult Res = getDerived().TransformExpr(AA->getAssumption());
2186 Res = getSema().ActOnFinishFullExpr(Res.
get(),
2191 if (!(Res.
get()->
getDependence() & ExprDependence::TypeValueInstantiation)) {
2192 Res = getSema().BuildCXXAssumeExpr(Res.
get(), AA->getAttrName(),
2198 return CXXAssumeAttr::CreateImplicit(getSema().
Context, Res.
get(),
2203TemplateInstantiator::TransformLoopHintAttr(
const LoopHintAttr *LH) {
2204 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).get();
2206 if (TransformedExpr == LH->getValue())
2211 LH->getSemanticSpelling() ==
2212 LoopHintAttr::Pragma_unroll))
2215 LoopHintAttr::OptionType Option = LH->getOption();
2216 LoopHintAttr::LoopHintState State = LH->getState();
2218 llvm::APSInt ValueAPS =
2221 if (ValueAPS.isZero() || ValueAPS.isOne()) {
2222 Option = LoopHintAttr::Unroll;
2223 State = LoopHintAttr::Disable;
2228 return LoopHintAttr::CreateImplicit(getSema().
Context, Option, State,
2229 TransformedExpr, *LH);
2231const NoInlineAttr *TemplateInstantiator::TransformStmtNoInlineAttr(
2232 const Stmt *OrigS,
const Stmt *InstS,
const NoInlineAttr *A) {
2238const AlwaysInlineAttr *TemplateInstantiator::TransformStmtAlwaysInlineAttr(
2239 const Stmt *OrigS,
const Stmt *InstS,
const AlwaysInlineAttr *A) {
2246const CodeAlignAttr *
2247TemplateInstantiator::TransformCodeAlignAttr(
const CodeAlignAttr *CA) {
2248 Expr *TransformedExpr = getDerived().TransformExpr(CA->getAlignment()).get();
2249 return getSema().BuildCodeAlignAttr(*CA, TransformedExpr);
2252ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
2255 std::optional<unsigned> PackIndex) {
2260 auto SubstParamType = [&] {
2267 T = cast<PackExpansionType>(
T)->getPattern();
2271 bool refParam =
false;
2277 Expr *argExpr =
arg.getAsExpr();
2282 QualType paramType = SubstParamType();
2297 VD = cast_or_null<ValueDecl>(
2303 QualType paramType =
arg.getNonTypeTemplateArgumentType();
2304 assert(!paramType.
isNull() &&
"type substitution failed for param type");
2305 assert(!paramType->
isDependentType() &&
"param type still dependent");
2309 QualType paramType =
arg.getNonTypeTemplateArgumentType();
2320 Expr *resultExpr = result.
get();
2324 AssociatedDecl, parm->
getIndex(), PackIndex, refParam);
2328TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
2338 return transformNonTypeTemplateParmRef(
2339 E->getAssociatedDecl(),
E->getParameterPack(),
2340 E->getParameterPackLocation(), Arg, getPackIndex(Pack));
2344TemplateInstantiator::TransformSubstNonTypeTemplateParmExpr(
2346 ExprResult SubstReplacement =
E->getReplacement();
2347 if (!isa<ConstantExpr>(SubstReplacement.
get()))
2348 SubstReplacement = TransformExpr(
E->getReplacement());
2377 SubstReplacement.
get(), SugaredConverted,
2381 return transformNonTypeTemplateParmRef(
E->getAssociatedDecl(),
2383 SugaredConverted,
E->getPackIndex());
2389 return getSema().BuildDeclarationNameExpr(
CXXScopeSpec(), NameInfo, PD);
2400 return RebuildVarDeclRefExpr(VD,
E->
getExprLoc());
2410 Vars.reserve(
E->getNumExpansions());
2421 E->getParameterPackLocation(), Vars);
2422 getSema().MarkFunctionParmPackReferenced(PackExpr);
2427TemplateInstantiator::TransformFunctionParmPackRefExpr(
DeclRefExpr *
E,
2430 llvm::PointerUnion<Decl *, DeclArgumentPack *> *
Found
2431 = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
2432 assert(
Found &&
"no instantiation for parameter pack");
2434 Decl *TransformedDecl;
2435 if (DeclArgumentPack *Pack =
Found->dyn_cast<DeclArgumentPack *>()) {
2444 getSema().MarkFunctionParmPackReferenced(PackExpr);
2448 TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
2450 TransformedDecl = cast<Decl *>(*
Found);
2454 return RebuildVarDeclRefExpr(cast<VarDecl>(TransformedDecl),
E->
getExprLoc());
2458TemplateInstantiator::TransformDeclRefExpr(
DeclRefExpr *
E) {
2465 return TransformTemplateParmRefExpr(
E, NTTP);
2472 if (
VarDecl *PD = dyn_cast<VarDecl>(
D))
2474 return TransformFunctionParmPackRefExpr(
E, PD);
2476 return inherited::TransformDeclRefExpr(
E);
2479ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
2481 assert(!cast<FunctionDecl>(
E->getParam()->getDeclContext())->
2482 getDescribedFunctionTemplate() &&
2483 "Default arg expressions are never formed in dependent cases.");
2485 E->getUsedLocation(), cast<FunctionDecl>(
E->getParam()->getDeclContext()),
2489template<
typename Fn>
2494 Fn TransformExceptionSpec) {
2503 std::optional<LocalInstantiationScope>
Scope;
2504 if (!Current || !Current->isLambdaOrBlock())
2507 return inherited::TransformFunctionProtoType(
2508 TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
2511ParmVarDecl *TemplateInstantiator::TransformFunctionTypeParam(
2513 std::optional<unsigned> NumExpansions,
bool ExpectParameterPack) {
2515 OldParm, TemplateArgs, indexAdjustment, NumExpansions,
2516 ExpectParameterPack, EvaluateConstraints);
2522QualType TemplateInstantiator::BuildSubstTemplateTypeParmType(
2524 Decl *AssociatedDecl,
unsigned Index, std::optional<unsigned> PackIndex,
2530 if (SuppressObjCLifetime) {
2532 RQs = Replacement.getQualifiers();
2543 QualType Result = getSema().Context.getSubstTemplateTypeParmType(
2544 Replacement, AssociatedDecl, Index, PackIndex);
2552TemplateInstantiator::TransformTemplateTypeParmType(
TypeLocBuilder &TLB,
2554 bool SuppressObjCLifetime) {
2565 IsIncomplete =
true;
2566 if (BailOutOnIncomplete)
2582 "unexpected pack arguments in template rewrite");
2586 "unexpected nontype template argument kind in template rewrite");
2592 auto [AssociatedDecl, Final] =
2594 std::optional<unsigned> PackIndex;
2595 if (
T->isParameterPack()) {
2597 "Missing argument pack");
2603 QualType Result = getSema().Context.getSubstTemplateTypeParmPackType(
2604 AssociatedDecl,
T->getIndex(), Final, Arg);
2612 PackIndex = getPackIndex(Arg);
2617 "Template argument kind mismatch");
2619 return BuildSubstTemplateTypeParmType(TLB, SuppressObjCLifetime, Final,
2620 AssociatedDecl,
T->getIndex(),
2630 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
2634 T->isParameterPack(), NewTTPDecl);
2640QualType TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
2642 bool SuppressObjCLifetime) {
2645 Decl *NewReplaced = TransformDecl(TL.
getNameLoc(),
T->getAssociatedDecl());
2650 if (NewReplaced !=
T->getAssociatedDecl())
2651 Result = getSema().Context.getSubstTemplateTypeParmPackType(
2652 NewReplaced,
T->getIndex(),
T->getFinal(),
T->getArgumentPack());
2661 return BuildSubstTemplateTypeParmType(
2662 TLB, SuppressObjCLifetime,
T->getFinal(), NewReplaced,
T->getIndex(),
2676 ErrorLoc = PDA.first;
2681 llvm::raw_svector_ostream
OS(Entity);
2685 C.backupStr(Entity), ErrorLoc,
C.backupStr(Message)};
2691 llvm::raw_svector_ostream
OS(Entity);
2695 C.backupStr(Entity),
2696 Location, StringRef()};
2699ExprResult TemplateInstantiator::TransformRequiresTypeParams(
2713 if (getDerived().TransformFunctionTypeParams(
2714 KWLoc, Params,
nullptr,
nullptr, PTypes,
2715 &TransParams, PInfos, &ErrorIdx) ||
2716 Trap.hasErrorOccurred()) {
2722 SemaRef, Info, [&](llvm::raw_ostream &
OS) {
OS << *FailedDecl; })));
2723 return getDerived().RebuildRequiresExpr(KWLoc, Body, RE->
getLParenLoc(),
2725 TransReqs, RBraceLoc);
2736 if (AlwaysRebuild())
2737 return RebuildTypeRequirement(
2747 if (TypeInst.isInvalid())
2750 if (!TransType || Trap.hasErrorOccurred())
2752 [&] (llvm::raw_ostream&
OS) {
2755 return RebuildTypeRequirement(TransType);
2765 llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *>
2774 if (ExprInst.isInvalid())
2777 if (!TransExprRes.
isInvalid() && !Trap.hasErrorOccurred() &&
2780 if (TransExprRes.
isInvalid() || Trap.hasErrorOccurred())
2785 TransExpr = TransExprRes.
get();
2788 std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;
2790 if (RetReq.isEmpty())
2791 TransRetReq.emplace();
2792 else if (RetReq.isSubstitutionFailure())
2793 TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
2794 else if (RetReq.isTypeConstraint()) {
2796 RetReq.getTypeConstraintTemplateParameterList();
2800 if (TPLInst.isInvalid())
2803 if (!TPL || Trap.hasErrorOccurred())
2805 [&] (llvm::raw_ostream&
OS) {
2806 RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()
2811 TransRetReq.emplace(TPL);
2814 assert(TransRetReq &&
"All code paths leading here must set TransRetReq");
2815 if (
Expr *
E = TransExpr.dyn_cast<
Expr *>())
2817 std::move(*TransRetReq));
2818 return RebuildExprRequirement(
2819 cast<concepts::Requirement::SubstitutionDiagnostic *>(TransExpr),
2824TemplateInstantiator::TransformNestedRequirement(
2829 if (AlwaysRebuild())
2838 if (!getEvaluateConstraints()) {
2840 if (TransConstraint.
isInvalid() || !TransConstraint.
get())
2860 if (ConstrInst.isInvalid())
2864 nullptr, {Req->getConstraintExpr()},
Result, TemplateArgs,
2867 TransConstraint =
Result[0];
2868 assert(!Trap.hasErrorOccurred() &&
"Substitution failures must be handled "
2869 "by CheckConstraintSatisfaction.");
2875 if (TransConstraint.
isInvalid() || !TransConstraint.
get() ||
2878 llvm::raw_svector_ostream
OS(Entity);
2892 bool AllowDeducedTST) {
2894 "Cannot perform an instantiation without some context on the "
2895 "instantiation stack");
2901 TemplateInstantiator Instantiator(*
this, Args,
Loc, Entity);
2902 return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(
T)
2903 : Instantiator.TransformType(
T);
2911 "Cannot perform an instantiation without some context on the "
2912 "instantiation stack");
2926 TemplateInstantiator Instantiator(*
this, Args,
Loc, Entity);
2940 bool *IsIncompleteSubstitution) {
2942 "Cannot perform an instantiation without some context on the "
2943 "instantiation stack");
2950 TemplateInstantiator Instantiator(
2951 *
this, TemplateArgs,
Loc, Entity,
2952 IsIncompleteSubstitution !=
nullptr);
2953 QualType QT = Instantiator.TransformType(
T);
2954 if (IsIncompleteSubstitution && Instantiator.getIsIncomplete())
2955 *IsIncompleteSubstitution =
true;
2964 TypeLoc TL =
T->getTypeLoc().IgnoreParens();
2987 bool EvaluateConstraints) {
2989 "Cannot perform an instantiation without some context on the "
2990 "instantiation stack");
2995 TemplateInstantiator Instantiator(*
this, Args,
Loc, Entity);
2996 Instantiator.setEvaluateConstraints(EvaluateConstraints);
3012 Result = Instantiator.TransformFunctionProtoType(
3013 TLB, Proto, ThisContext, ThisTypeQuals,
3015 bool &Changed) {
return false; });
3017 Result = Instantiator.TransformType(TLB, TL);
3031 bool Changed =
false;
3033 return Instantiator.TransformExceptionSpec(
Loc, ESI, ExceptionStorage,
3044 ESI, ExceptionStorage, Args))
3053 struct GetContainedInventedTypeParmVisitor :
3054 public TypeVisitor<GetContainedInventedTypeParmVisitor,
3055 TemplateTypeParmDecl *> {
3056 using TypeVisitor<GetContainedInventedTypeParmVisitor,
3062 return Visit(
T.getTypePtr());
3067 if (!
T->getDecl() || !
T->getDecl()->isImplicit())
3069 return T->getDecl();
3076 return Visit(
T->getNamedType());
3088 return Visit(
T->getPointeeTypeAsWritten());
3096 return Visit(
T->getElementType());
3101 return Visit(
T->getElementType());
3105 return Visit(
T->getElementType());
3109 return VisitFunctionType(
T);
3117 return Visit(
T->getInnerType());
3121 return Visit(
T->getModifiedType());
3125 return Visit(
T->getUnderlyingType());
3129 return Visit(
T->getOriginalType());
3133 return Visit(
T->getPattern());
3141struct ExpandPackedTypeConstraints
3148 ExpandPackedTypeConstraints(
3150 : inherited(SemaRef), TemplateArgs(TemplateArgs) {}
3152 using inherited::TransformTemplateTypeParmType;
3157 if (!
T->isParameterPack()) {
3168 std::optional<unsigned> PackIndex;
3173 TL.
getType(),
T->getDecl(),
T->getIndex(), PackIndex,
3174 SubstTemplateTypeParmTypeFlag::ExpandPacksInPlace);
3184 if (
T->getPackIndex()) {
3190 return inherited::TransformSubstTemplateTypeParmType(TLB, TL);
3195 return inherited::TransformTemplateArguments(Args.begin(), Args.end(), Out);
3204 bool EvaluateConstraints) {
3208 if (!EvaluateConstraints) {
3209 bool ShouldExpandExplicitTemplateArgs =
3211 llvm::any_of(TemplArgInfo->
arguments(), [](
auto &Arg) {
3212 return Arg.getArgument().containsUnexpandedParameterPack();
3229 if (ShouldExpandExplicitTemplateArgs) {
3233 if (ExpandPackedTypeConstraints(*
this, TemplateArgs)
3241 if (
auto *FE = dyn_cast<CXXFoldExpr>(ConstraintExpr)) {
3242 assert(FE->getLHS());
3243 ConstraintExpr = FE->getLHS();
3245 auto *CSE = cast<ConceptSpecializationExpr>(ConstraintExpr);
3246 assert(!CSE->getTemplateArguments().empty() &&
3247 "Empty template arguments?");
3248 ConstrainedType = CSE->getTemplateArguments()[0].getAsType();
3249 assert(!ConstrainedType.
isNull() &&
3250 "Failed to extract the original ConstrainedType?");
3256 Inst, ConstrainedType,
3289 int indexAdjustment, std::optional<unsigned> NumExpansions,
3290 bool ExpectParameterPack,
bool EvaluateConstraint) {
3299 NewDI =
SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
3310 }
else if (ExpectParameterPack) {
3316 diag::err_function_parameter_pack_without_parameter_packs)
3340 GetContainedInventedTypeParmVisitor().Visit(OldDI->
getType())) {
3342 auto *Inst = cast_or_null<TemplateTypeParmDecl>(
3347 if (Inst && !Inst->getTypeConstraint()) {
3416 "Cannot perform an instantiation without some context on the "
3417 "instantiation stack");
3419 TemplateInstantiator Instantiator(*
this, TemplateArgs,
Loc,
3421 return Instantiator.TransformFunctionTypeParams(
3422 Loc, Params,
nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
3440 Diag(Param->
getBeginLoc(), diag::err_recursive_default_argument) << FD;
3452 std::unique_ptr<LocalInstantiationScope> LIS;
3460 LIS = std::make_unique<LocalInstantiationScope>(*
this);
3463 if (addInstantiatedParametersToScope(FD, PatternFD, *LIS, TemplateArgs))
3485 Result = InitSeq.Perform(*
this, Entity, Kind, ResultE);
3512 for (
const auto &
Base : Pattern->
bases()) {
3513 if (!
Base.getType()->isDependentType()) {
3515 if (RD->isInvalidDecl())
3524 if (
Base.isPackExpansion()) {
3530 bool ShouldExpand =
false;
3531 bool RetainExpansion =
false;
3532 std::optional<unsigned> NumExpansions;
3534 Base.getSourceRange(),
3536 TemplateArgs, ShouldExpand,
3545 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3550 Base.getSourceRange().getBegin(),
3559 Base.getSourceRange(),
3561 Base.getAccessSpecifierAsWritten(),
3564 InstantiatedBases.push_back(InstantiatedBase);
3573 EllipsisLoc =
Base.getEllipsisLoc();
3577 Base.getSourceRange().getBegin(),
3582 Base.getSourceRange().getBegin(),
3593 Base.getSourceRange(),
3595 Base.getAccessSpecifierAsWritten(),
3598 InstantiatedBases.push_back(InstantiatedBase);
3630 Pattern, PatternDef, TSK, Complain))
3633 llvm::TimeTraceScope TimeScope(
"InstantiateClass", [&]() {
3634 llvm::TimeTraceMetadata M;
3635 llvm::raw_string_ostream
OS(M.Detail);
3638 if (llvm::isTimeTraceVerbose()) {
3646 Pattern = PatternDef;
3652 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3654 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
3655 Spec->setTemplateSpecializationKind(TSK);
3656 Spec->setPointOfInstantiation(PointOfInstantiation);
3664 "instantiating class definition");
3682 SavePendingParsedClassStateRAII SavedPendingParsedClassState(*
this);
3708 bool MightHaveConstexprVirtualFunctions =
false;
3719 if (
Member->getDeclContext() != Pattern)
3726 if (isa<BlockDecl>(
Member) ||
3727 (isa<CXXRecordDecl>(
Member) && cast<CXXRecordDecl>(
Member)->isLambda()))
3730 if (
Member->isInvalidDecl()) {
3737 if (
FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
3738 Fields.push_back(Field);
3739 }
else if (
EnumDecl *
Enum = dyn_cast<EnumDecl>(NewMember)) {
3745 Enum->isCompleteDefinition()) {
3747 assert(MSInfo &&
"no spec info for member enum specialization");
3752 if (SA->isFailed()) {
3758 }
else if (
CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewMember)) {
3761 MightHaveConstexprVirtualFunctions =
true;
3782 if (ParsingClassDepth == 0)
3787 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
3788 E = LateAttrs.end(); I !=
E; ++I) {
3793 auto *ND = cast<NamedDecl>(I->NewDecl);
3794 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
3796 ND->isCXXInstanceMember());
3801 I->NewDecl->addAttr(NewAttr);
3830 P->first,
P->second)) {
3843 P->first,
P->second)) {
3860 else if (MightHaveConstexprVirtualFunctions)
3877 Pattern, PatternDef, TSK,
true))
3879 Pattern = PatternDef;
3885 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3894 "instantiating enum definition");
3929 "pattern and instantiation disagree about init style");
3937 Diag(PointOfInstantiation,
3938 diag::err_default_member_initializer_not_yet_parsed)
3939 << OutermostClass << Pattern;
3940 Diag(Pattern->getEndLoc(),
3941 diag::note_default_member_initializer_not_yet_parsed);
3951 Diag(PointOfInstantiation, diag::err_default_member_initializer_cycle)
3956 "instantiating default member init");
3964 PointOfInstantiation, Instantiation,
CurContext};
3975 assert((!
Init || !isa<ParenListExpr>(
Init)) &&
"call-style init in class");
3980 L->DefaultMemberInitializerInstantiated(Instantiation);
3989 struct PartialSpecMatchResult {
4015 !CTPSD->getMostRecentDecl()->isMemberSpecialization())
4035 bool PrimaryHasMatchedPackOnParmToNonPackOnArg) {
4045 if (!isa<ClassTemplatePartialSpecializationDecl *>(Specialized)) {
4074 !Partial->getMostRecentDecl()->isMemberSpecialization())
4093 if (Matched.empty() && PrimaryHasMatchedPackOnParmToNonPackOnArg)
4094 Matched = std::move(ExtraMatched);
4100 if (Matched.size() >= 1) {
4102 if (Matched.size() == 1) {
4115 PEnd = Matched.end();
4118 P->Partial, Best->Partial, PointOfInstantiation) ==
4125 bool Ambiguous =
false;
4127 PEnd = Matched.end();
4130 P->Partial, Best->Partial,
4131 PointOfInstantiation) != Best->Partial) {
4141 S.
Diag(PointOfInstantiation,
4142 diag::err_partial_spec_ordering_ambiguous)
4143 << ClassTemplateSpec;
4147 PEnd = Matched.end();
4149 S.
Diag(
P->Partial->getLocation(), diag::note_partial_spec_match)
4151 P->Partial->getTemplateParameters(), *
P->Args);
4166 if (
auto *PartialSpec =
4169 while (PartialSpec->getInstantiatedFromMember()) {
4172 if (PartialSpec->isMemberSpecialization())
4175 PartialSpec = PartialSpec->getInstantiatedFromMember();
4177 Pattern = PartialSpec;
4198 bool PrimaryHasMatchedPackOnParmToNonPackOnArg) {
4200 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
4207 *
this, PointOfInstantiation, ClassTemplateSpec, TSK,
4208 PrimaryHasMatchedPackOnParmToNonPackOnArg);
4213 PointOfInstantiation, ClassTemplateSpec, Pattern.
get(),
4229 "Unexpected template specialization kind!");
4230 for (
auto *
D : Instantiation->
decls()) {
4231 bool SuppressNew =
false;
4232 if (
auto *
Function = dyn_cast<FunctionDecl>(
D)) {
4234 Function->getInstantiatedFromMemberFunction()) {
4236 if (
Function->isIneligibleOrNotSelected())
4239 if (
Function->getTrailingRequiresClause()) {
4247 if (
Function->hasAttr<ExcludeFromExplicitInstantiationAttr>())
4251 Function->getTemplateSpecializationKind();
4256 PointOfInstantiation, TSK,
Function, PrevTSK,
4257 Function->getPointOfInstantiation(), SuppressNew) ||
4270 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
4280 std::make_pair(
Function, PointOfInstantiation));
4283 }
else if (
auto *Var = dyn_cast<VarDecl>(
D)) {
4284 if (isa<VarTemplateSpecializationDecl>(Var))
4288 if (Var->
hasAttr<ExcludeFromExplicitInstantiationAttr>())
4292 assert(MSInfo &&
"No member specialization information?");
4321 }
else if (
auto *
Record = dyn_cast<CXXRecordDecl>(
D)) {
4322 if (
Record->hasAttr<ExcludeFromExplicitInstantiationAttr>())
4330 if (
Record->isInjectedClassName() ||
Record->getPreviousDecl() ||
4335 assert(MSInfo &&
"No member specialization information?");
4361 assert(Pattern &&
"Missing instantiated-from-template information");
4363 if (!
Record->getDefinition()) {
4384 Record->getTemplateSpecializationKind() ==
4386 Record->setTemplateSpecializationKind(TSK);
4391 Pattern = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
4395 }
else if (
auto *
Enum = dyn_cast<EnumDecl>(
D)) {
4397 assert(MSInfo &&
"No member specialization information?");
4404 PointOfInstantiation, TSK,
Enum,
4410 if (
Enum->getDefinition())
4413 EnumDecl *Pattern =
Enum->getTemplateInstantiationPattern();
4414 assert(Pattern &&
"Missing instantiated-from-template information");
4425 }
else if (
auto *Field = dyn_cast<FieldDecl>(
D)) {
4432 ClassPattern->
lookup(Field->getDeclName());
4465 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4468 return Instantiator.TransformStmt(S);
4476 TemplateInstantiator Instantiator(*
this, TemplateArgs,
Loc, Entity);
4477 return Instantiator.TransformTemplateArgument(Input, Output);
4484 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4486 return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(), Out);
4494 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4497 return Instantiator.TransformExpr(
E);
4513 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4515 Instantiator.setEvaluateConstraints(
false);
4516 return Instantiator.TransformExpr(
E);
4521 bool CXXDirectInit) {
4522 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4524 return Instantiator.TransformInitializer(
Init, CXXDirectInit);
4533 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4536 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
4546 TemplateInstantiator Instantiator(*
this, TemplateArgs, NNS.
getBeginLoc(),
4548 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
4554 TemplateInstantiator Instantiator(*
this, TemplateArgs, NameInfo.
getLoc(),
4556 return Instantiator.TransformDeclarationNameInfo(NameInfo);
4563 TemplateInstantiator Instantiator(*
this, TemplateArgs,
Loc,
4566 SS.
Adopt(QualifierLoc);
4567 return Instantiator.TransformTemplateName(SS, Name,
Loc);
4575 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(
D)) {
4576 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
4577 unsigned i = PV->getFunctionScopeIndex();
4580 if (i < FD->getNumParams() && FD->getParamDecl(i) == PV)
4588llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
4592 Current = Current->Outer) {
4595 const Decl *CheckD =
D;
4597 LocalDeclsMap::iterator
Found = Current->LocalDecls.find(CheckD);
4598 if (
Found != Current->LocalDecls.end())
4599 return &
Found->second;
4603 if (
const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
4604 CheckD = Tag->getPreviousDecl();
4610 if (!Current->CombineWithOuterScope)
4616 if (isa<NonTypeTemplateParmDecl>(
D) || isa<TemplateTypeParmDecl>(
D) ||
4617 isa<TemplateTemplateParmDecl>(
D))
4622 if (RD->isLocalClass())
4627 if (isa<EnumDecl>(
D))
4632 if (isa<TypedefNameDecl>(
D) &&
4639 assert(isa<LabelDecl>(
D) &&
"declaration not instantiated in this scope");
4645 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[
D];
4646 if (Stored.isNull()) {
4650 while (Current->CombineWithOuterScope && Current->Outer) {
4651 Current = Current->Outer;
4652 assert(!Current->LocalDecls.contains(
D) &&
4653 "Instantiated local in inner and outer scopes");
4657 }
else if (
DeclArgumentPack *Pack = dyn_cast<DeclArgumentPack *>(Stored)) {
4658 Pack->push_back(cast<VarDecl>(Inst));
4660 assert(cast<Decl *>(Stored) == Inst &&
"Already instantiated this local");
4668 Pack->push_back(Inst);
4675 Current && Current->CombineWithOuterScope; Current = Current->Outer)
4676 assert(!Current->LocalDecls.contains(
D) &&
4677 "Creating local pack after instantiation of local");
4681 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[
D];
4684 ArgumentPacks.push_back(Pack);
4689 if (llvm::is_contained(*Pack,
D))
4696 unsigned NumExplicitArgs) {
4697 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
4698 "Already have a partially-substituted pack");
4699 assert((!PartiallySubstitutedPack
4700 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
4701 "Wrong number of arguments in partially-substituted pack");
4702 PartiallySubstitutedPack = Pack;
4703 ArgsInPartiallySubstitutedPack = ExplicitArgs;
4704 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
4709 unsigned *NumExplicitArgs)
const {
4711 *ExplicitArgs =
nullptr;
4712 if (NumExplicitArgs)
4713 *NumExplicitArgs = 0;
4716 Current = Current->Outer) {
4717 if (Current->PartiallySubstitutedPack) {
4719 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
4720 if (NumExplicitArgs)
4721 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
4723 return Current->PartiallySubstitutedPack;
4726 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 &ASTCtx, QualType Ty)
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
MatchFinder::MatchResult MatchResult
static const Decl * getCanonicalParmVarDecl(const Decl *D)
static ActionResult< CXXRecordDecl * > getPatternForClassTemplateSpecialization(Sema &S, SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool PrimaryHasMatchedPackOnParmToNonPackOnArg)
Get the instantiation pattern to use to instantiate the definition of a given ClassTemplateSpecializa...
static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T)
static concepts::Requirement::SubstitutionDiagnostic * createSubstDiag(Sema &S, TemplateDeductionInfo &Info, Sema::EntityPrinter Printer)
static std::string convertCallArgsToString(Sema &S, llvm::ArrayRef< const Expr * > Args)
static TemplateArgument getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg)
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 getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex, SubstTemplateTypeParmTypeFlag Flag=SubstTemplateTypeParmTypeFlag::None) const
Retrieve a substitution-result type.
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.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Attr - This represents one attribute.
An attributed type is a type to which a type attribute has been applied.
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Represents a base class of a C++ class.
A default argument (C++ [dcl.fct.default]).
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,...
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
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.
ClassTemplateDecl * getMostRecentDecl()
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.
Decl - This represents one declaration (or definition), e.g.
TemplateDecl * getDescribedTemplate() const
If this is a declaration that describes some template, this method returns that template declaration.
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
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.
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.
Recursive AST visitor that supports extension via dynamic dispatch.
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
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.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
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.
ExprDependence getDependence() const
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 *const * iterator
Iterators over the parameters which the parameter pack expanded into.
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.
A pointer to member type per C++ 8.3.3 - Pointers to members.
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.
Sugar for parentheses used when specifying types.
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.
[C99 6.4.2.2] - A predefined identifier such as func.
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.
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.
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
Scope - A scope is a transient data structure that is used while parsing the program.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
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
bool isComparison() const
CXXSpecialMemberKind asSpecialMember() 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.
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
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)
bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, CheckTemplateArgumentKind CTAK, bool PartialOrdering, bool *MatchedPackOnParmToNonPackOnArg)
Check that the given template argument corresponds to the given template parameter.
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.
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)
llvm::function_ref< void(llvm::raw_ostream &)> EntityPrinter
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
concepts::Requirement::SubstitutionDiagnostic * createSubstDiagAt(SourceLocation Location, EntityPrinter Printer)
create a Requirement::SubstitutionDiagnostic with only a SubstitutedEntity and DiagLoc using ASTConte...
@ 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...
void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
const LangOptions & getLangOpts() const
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, QualType ConstrainedType, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
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.
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 InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true, bool PrimaryHasMatchedPackOnParmToNonPackOnArg=false)
bool usesPartialOrExplicitSpecialization(SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec)
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
bool CheckLoopHintExpr(Expr *E, SourceLocation Loc, bool AllowZero)
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)
Check the validity of a C++ base class 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.
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, bool ForDefaultArgumentSubstitution=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, const IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
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)
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, ExprResult Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member,...
bool CheckAlwaysInlineAttr(const Stmt *OrigSt, const Stmt *CurSt, const AttributeCommonInfo &A)
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 SubstTemplateArgument(const TemplateArgumentLoc &Input, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentLoc &Output, SourceLocation Loc={}, const DeclarationName &Entity={})
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.
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)
bool RebuildingImmediateInvocation
Whether the AST is currently being rebuilt to correct immediate invocations.
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.
SourceManager & SourceMgr
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)
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.
ExprResult BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Given a non-type template argument that refers to a declaration and the type of its corresponding non...
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)
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.
unsigned getExpansionLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
StringRef getFilename(SourceLocation SpellingLoc) const
Return the filename of the file containing a SourceLocation.
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
A trivial tuple used to represent a source range.
void warnOnStackNearlyExhausted(SourceLocation Loc)
Check to see if we're low on stack space and produce a warning if we're low on stack space (Currently...
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...
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
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.
Wrapper for substituted template type parameters.
Represents the result of substituting a type for a template type parameter.
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.
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.
bool isDependent() const
Whether this template argument is dependent on a template parameter such that its result can change f...
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.
TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) const
Retrieve the underlying template declaration that this template name refers to, if known.
bool isNull() const
Determine whether this template name is NULL.
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.
bool isParameterPack() const
unsigned getIndex() const
unsigned getDepth() const
Declaration of an alias template.
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
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
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
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
QualType getUnderlyingType() 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.
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
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
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?
bool hasMatchedPackOnParmToNonPackOnArg() const
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
Defines the clang::TargetInfo interface.
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 isGenericLambdaCallOperatorOrStaticInvokerSpecialization(const DeclContext *DC)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
std::pair< unsigned, unsigned > getDepthAndIndex(const NamedDecl *ND)
Retrieve the depth and index of a template parameter.
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.
@ 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.
const FunctionProtoType * T
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
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.
@ TypeAliasTemplateInstantiation
We are instantiating a type alias template declaration.
@ BuildingDeductionGuides
We are building deduction guides for a class.
@ PartialOrderingTTP
We are performing partial ordering for template template parameters.
@ 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)
Contains all information for a given match.