38#include "llvm/ADT/StringExtras.h"
39#include "llvm/Support/ErrorHandling.h"
40#include "llvm/Support/SaveAndRestore.h"
41#include "llvm/Support/TimeProfiler.h"
54 const Decl *NextDecl =
nullptr;
56 bool ClearRelativeToPrimary =
true;
57 static Response Done() {
62 static Response ChangeDecl(
const Decl *ND) {
67 static Response ChangeDecl(
const DeclContext *Ctx) {
73 static Response UseNextDecl(
const Decl *CurDecl) {
77 static Response DontClearRelativeToPrimaryNextDecl(
const Decl *CurDecl) {
78 Response R = Response::UseNextDecl(CurDecl);
79 R.ClearRelativeToPrimary =
false;
88getPrimaryTemplateOfGenericLambda(
const FunctionDecl *LambdaCallOperator) {
90 return LambdaCallOperator;
92 if (
auto *FTD = dyn_cast_if_present<FunctionTemplateDecl>(
94 FTD && FTD->getInstantiatedFromMemberTemplate()) {
96 FTD->getInstantiatedFromMemberTemplate()->getTemplatedDecl();
103 ->getInstantiatedFromMemberFunction())
104 LambdaCallOperator = Prev;
108 return LambdaCallOperator;
111struct EnclosingTypeAliasTemplateDetails {
121EnclosingTypeAliasTemplateDetails
122getEnclosingTypeAliasTemplateDecl(
Sema &SemaRef) {
125 TypeAliasTemplateInstantiation)
127 EnclosingTypeAliasTemplateDetails Result;
129 *
Next = TATD->getInstantiatedFromMemberTemplate();
133 CSC.template_arguments(),
136 Result.PrimaryTypeAliasDecl =
Next;
137 Next =
Next->getInstantiatedFromMemberTemplate();
150bool isLambdaEnclosedByTypeAliasDecl(
154 Visitor(
const FunctionDecl *CallOperator) : CallOperator(CallOperator) {}
155 bool VisitLambdaExpr(
LambdaExpr *LE)
override {
158 return getPrimaryTemplateOfGenericLambda(LE->getCallOperator()) !=
167 return !Visitor(getPrimaryTemplateOfGenericLambda(LambdaCallOperator))
168 .TraverseType(Underlying);
175 bool SkipForSpecialization) {
179 return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);
184 return Response::Done();
189 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
192 dyn_cast<VarTemplatePartialSpecializationDecl *>(Specialized)) {
193 if (!SkipForSpecialization)
194 Result.addOuterTemplateArguments(
197 if (Partial->isMemberSpecialization())
198 return Response::Done();
201 if (!SkipForSpecialization)
202 Result.addOuterTemplateArguments(
206 return Response::Done();
208 return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);
220 for (
unsigned I = 0, N = TTP->
getDepth() + 1; I != N; ++I)
221 Result.addOuterTemplateArguments(std::nullopt);
222 return Response::Done();
225Response HandlePartialClassTemplateSpec(
228 if (!SkipForSpecialization)
230 return Response::Done();
237 bool SkipForSpecialization) {
242 return Response::Done();
244 if (!SkipForSpecialization)
245 Result.addOuterTemplateArguments(
254 return Response::Done();
260 if (
auto *InstFromPartialTempl =
263 return Response::ChangeDecl(
264 InstFromPartialTempl->getLexicalDeclContext());
266 return Response::UseNextDecl(ClassTemplSpec);
272 bool ForConstraintInstantiation,
273 bool ForDefaultArgumentSubstitution) {
275 if (!RelativeToPrimary &&
276 Function->getTemplateSpecializationKindForInstantiation() ==
278 return Response::Done();
280 if (!RelativeToPrimary &&
285 return Response::UseNextDecl(Function);
287 Function->getTemplateSpecializationArgs()) {
289 Result.addOuterTemplateArguments(
const_cast<FunctionDecl *
>(Function),
290 TemplateArgs->asArray(),
293 if (RelativeToPrimary &&
294 (Function->getTemplateSpecializationKind() ==
296 (Function->getFriendObjectKind() &&
297 !Function->getPrimaryTemplate()->getFriendObjectKind())))
298 return Response::UseNextDecl(Function);
302 assert(Function->getPrimaryTemplate() &&
"No function template?");
303 if (!ForDefaultArgumentSubstitution &&
304 Function->getPrimaryTemplate()->isMemberSpecialization())
305 return Response::Done();
308 if (!ForConstraintInstantiation &&
310 return Response::Done();
312 }
else if (
auto *
Template = Function->getDescribedFunctionTemplate()) {
314 (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
315 "Outer template not instantiated?");
316 if (ForConstraintInstantiation) {
324 Result.addOuterTemplateArguments(
Template, Inst.template_arguments(),
335 if ((Function->getFriendObjectKind() || Function->isLocalExternDecl()) &&
336 Function->getNonTransparentDeclContext()->isFileContext() &&
338 return Response::ChangeDecl(Function->getLexicalDeclContext());
341 if (ForConstraintInstantiation && Function->getFriendObjectKind())
342 return Response::ChangeDecl(Function->getLexicalDeclContext());
343 return Response::UseNextDecl(Function);
346Response HandleFunctionTemplateDecl(
Sema &SemaRef,
350 Result.addOuterTemplateArguments(
363 Ty = std::exchange(NextTy,
nullptr)) {
366 NextTy = P.getAsType();
367 const auto *TSTy = dyn_cast<TemplateSpecializationType>(Ty);
389 if (TSTy->isCurrentInstantiation()) {
390 auto *RD = TSTy->getCanonicalTypeInternal()->getAsCXXRecordDecl();
392 Arguments = CTD->getInjectedTemplateArgs(SemaRef.
Context);
394 dyn_cast<ClassTemplateSpecializationDecl>(RD))
395 Arguments =
Specialization->getTemplateInstantiationArgs().asArray();
397 Result.addOuterTemplateArguments(
398 TSTy->getTemplateName().getAsTemplateDecl(), Arguments,
409 bool ForConstraintInstantiation) {
412 (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
413 "Outer template not instantiated?");
414 if (ClassTemplate->isMemberSpecialization())
415 return Response::Done();
416 if (ForConstraintInstantiation)
417 Result.addOuterTemplateArguments(
419 ClassTemplate->getInjectedTemplateArgs(SemaRef.
Context),
426 return Response::Done();
431 if (ForConstraintInstantiation && IsFriend &&
440 return Response::ChangeDecl(LCD);
444 if (
auto TypeAlias = getEnclosingTypeAliasTemplateDecl(SemaRef);
445 ForConstraintInstantiation &&
TypeAlias) {
448 Result.addOuterTemplateArguments(
TypeAlias.Template,
464 return Response::ChangeDecl(
TypeAlias.Template->getDeclContext());
469 return Response::UseNextDecl(Rec);
472Response HandleImplicitConceptSpecializationDecl(
475 Result.addOuterTemplateArguments(
479 return Response::UseNextDecl(CSD);
482Response HandleGenericDeclContext(
const Decl *CurDecl) {
483 return Response::UseNextDecl(CurDecl);
491 const FunctionDecl *Pattern,
bool ForConstraintInstantiation,
492 bool SkipForSpecialization,
bool ForDefaultArgumentSubstitution) {
493 assert((ND || DC) &&
"Can't find arguments for a decl if one isn't provided");
498 const Decl *CurDecl = ND;
501 Result.addOuterTemplateArguments(
const_cast<NamedDecl *
>(ND), *Innermost,
511 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl))
512 HandleDefaultTempArgIntoTempTempParam(TTP,
Result);
514 : Response::UseNextDecl(CurDecl).NextDecl;
520 if (
const auto *VarTemplSpec =
521 dyn_cast<VarTemplateSpecializationDecl>(CurDecl)) {
522 R = HandleVarTemplateSpec(VarTemplSpec,
Result, SkipForSpecialization);
523 }
else if (
const auto *PartialClassTemplSpec =
524 dyn_cast<ClassTemplatePartialSpecializationDecl>(CurDecl)) {
525 R = HandlePartialClassTemplateSpec(PartialClassTemplSpec,
Result,
526 SkipForSpecialization);
527 }
else if (
const auto *ClassTemplSpec =
528 dyn_cast<ClassTemplateSpecializationDecl>(CurDecl)) {
529 R = HandleClassTemplateSpec(ClassTemplSpec,
Result,
530 SkipForSpecialization);
531 }
else if (
const auto *
Function = dyn_cast<FunctionDecl>(CurDecl)) {
532 R = HandleFunction(*
this,
Function,
Result, Pattern, RelativeToPrimary,
533 ForConstraintInstantiation,
534 ForDefaultArgumentSubstitution);
535 }
else if (
const auto *Rec = dyn_cast<CXXRecordDecl>(CurDecl)) {
537 ForConstraintInstantiation);
538 }
else if (
const auto *CSD =
539 dyn_cast<ImplicitConceptSpecializationDecl>(CurDecl)) {
540 R = HandleImplicitConceptSpecializationDecl(CSD,
Result);
541 }
else if (
const auto *FTD = dyn_cast<FunctionTemplateDecl>(CurDecl)) {
542 R = HandleFunctionTemplateDecl(*
this, FTD,
Result);
543 }
else if (
const auto *CTD = dyn_cast<ClassTemplateDecl>(CurDecl)) {
544 R = Response::ChangeDecl(CTD->getLexicalDeclContext());
546 R = Response::DontClearRelativeToPrimaryNextDecl(CurDecl);
547 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl)) {
548 R = HandleDefaultTempArgIntoTempTempParam(TTP,
Result);
551 R = HandleGenericDeclContext(CurDecl);
556 if (R.ClearRelativeToPrimary)
557 RelativeToPrimary =
false;
559 CurDecl = R.NextDecl;
602 llvm_unreachable(
"Invalid SynthesisKind!");
614 if (
SemaRef.Diags.hasFatalErrorOccurred() &&
615 SemaRef.hasUncompilableErrorOccurred()) {
629 Inst.InConstraintSubstitution =
631 Inst.InParameterMappingSubstitution =
633 if (!
SemaRef.CodeSynthesisContexts.empty()) {
634 Inst.InConstraintSubstitution |=
635 SemaRef.CodeSynthesisContexts.back().InConstraintSubstitution;
636 Inst.InParameterMappingSubstitution |=
637 SemaRef.CodeSynthesisContexts.back().InParameterMappingSubstitution;
642 AlreadyInstantiating =
645 : !
SemaRef.InstantiatingSpecializations
646 .insert({Inst.Entity->getCanonicalDecl(), Inst.Kind})
657 PointOfInstantiation, InstantiationRange, Entity) {}
664 PointOfInstantiation, InstantiationRange, Entity) {}
684 TemplateArgs, &DeductionInfo) {
699 TemplateArgs, &DeductionInfo) {}
709 PointOfInstantiation, InstantiationRange, PartialSpec,
nullptr,
710 TemplateArgs, &DeductionInfo) {}
720 PointOfInstantiation, InstantiationRange, PartialSpec,
nullptr,
721 TemplateArgs, &DeductionInfo) {}
729 PointOfInstantiation, InstantiationRange, Param,
nullptr,
739 PointOfInstantiation, InstantiationRange, Param,
Template,
749 PointOfInstantiation, InstantiationRange, Param,
Template,
758 PointOfInstantiation, InstantiationRange, Entity,
767 PointOfInstantiation, InstantiationRange, Param,
Template,
776 PointOfInstantiation, InstantiationRange,
nullptr,
777 nullptr, {}, &DeductionInfo) {}
785 PointOfInstantiation, InstantiationRange,
nullptr,
793 PointOfInstantiation, InstantiationRange,
nullptr,
794 nullptr, {}, &DeductionInfo) {}
812 {}, &DeductionInfo) {}
820 PointOfInstantiation, InstantiationRange,
Template) {}
828 PointOfInstantiation, InstantiationRange,
Template) {}
835 PointOfInstantiation, InstantiationRange, Entity) {}
841 ArgLoc, InstantiationRange, PArg) {}
850 assert(
SemaRef.NonInstantiationEntries <=
851 SemaRef.CodeSynthesisContexts.size());
852 if ((
SemaRef.CodeSynthesisContexts.size() -
853 SemaRef.NonInstantiationEntries) >
854 SemaRef.getLangOpts().InstantiationDepth) {
856 diag::err_template_recursion_depth_exceeded)
859 diag::note_template_recursion_depth)
860 <<
SemaRef.getLangOpts().InstantiationDepth;
875 if (!Active.isInstantiationRecord()) {
885 "forgot to remove a lookup module for a template instantiation");
904 if (!AlreadyInstantiating) {
905 auto &Active = SemaRef.CodeSynthesisContexts.back();
907 SemaRef.InstantiatingSpecializations.erase(
908 {Active.Entity->getCanonicalDecl(), Active.Kind});
912 SemaRef.CodeSynthesisContexts.back());
914 SemaRef.popCodeSynthesisContext();
922 llvm::raw_string_ostream
OS(Result);
923 llvm::ListSeparator Comma;
924 for (
const Expr *Arg : Args) {
926 Arg->IgnoreParens()->printPretty(
OS,
nullptr,
935 unsigned Limit =
Diags.getTemplateBacktraceLimit();
937 SkipStart = Limit / 2 + Limit % 2;
942 unsigned InstantiationIdx = 0;
947 ++Active, ++InstantiationIdx) {
949 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
950 if (InstantiationIdx == SkipStart) {
952 DiagFunc(Active->PointOfInstantiation,
953 PDiag(diag::note_instantiation_contexts_suppressed)
959 switch (Active->Kind) {
961 Decl *D = Active->Entity;
963 unsigned DiagID = diag::note_template_member_class_here;
965 DiagID = diag::note_template_class_instantiation_here;
966 DiagFunc(Active->PointOfInstantiation,
967 PDiag(DiagID) <<
Record << Active->InstantiationRange);
971 DiagID = diag::note_function_template_spec_here;
973 DiagID = diag::note_template_member_function_here;
974 DiagFunc(Active->PointOfInstantiation,
976 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
977 DiagFunc(Active->PointOfInstantiation,
978 PDiag(VD->isStaticDataMember()
979 ? diag::note_template_static_data_member_def_here
980 : diag::note_template_variable_def_here)
981 << VD << Active->InstantiationRange);
982 }
else if (
EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
983 DiagFunc(Active->PointOfInstantiation,
984 PDiag(diag::note_template_enum_def_here)
985 << ED << Active->InstantiationRange);
986 }
else if (
FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
987 DiagFunc(Active->PointOfInstantiation,
988 PDiag(diag::note_template_nsdmi_here)
989 << FD << Active->InstantiationRange);
991 DiagFunc(Active->PointOfInstantiation,
992 PDiag(diag::note_template_class_instantiation_here)
993 << CTD << Active->InstantiationRange);
1001 llvm::raw_svector_ostream
OS(TemplateArgsStr);
1003 printTemplateArgumentList(
OS, Active->template_arguments(),
1005 DiagFunc(Active->PointOfInstantiation,
1006 PDiag(diag::note_default_arg_instantiation_here)
1007 <<
OS.str() << Active->InstantiationRange);
1013 DiagFunc(Active->PointOfInstantiation,
1014 PDiag(diag::note_explicit_template_arg_substitution_here)
1018 Active->NumTemplateArgs)
1019 << Active->InstantiationRange);
1025 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
1027 Active->PointOfInstantiation,
1028 PDiag(diag::note_function_template_deduction_instantiation_here)
1031 FnTmpl->getTemplateParameters(), Active->TemplateArgs,
1032 Active->NumTemplateArgs)
1033 << Active->InstantiationRange);
1037 bool IsTemplate =
false;
1039 if (
auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
1041 Params = D->getTemplateParameters();
1042 }
else if (
auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
1044 Params = D->getTemplateParameters();
1045 }
else if (
auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
1047 Params = D->getTemplateParameters();
1049 llvm_unreachable(
"unexpected template kind");
1052 DiagFunc(Active->PointOfInstantiation,
1053 PDiag(diag::note_deduced_template_arg_substitution_here)
1056 Active->TemplateArgs,
1057 Active->NumTemplateArgs)
1058 << Active->InstantiationRange);
1068 llvm::raw_svector_ostream
OS(TemplateArgsStr);
1070 printTemplateArgumentList(
OS, Active->template_arguments(),
1072 DiagFunc(Active->PointOfInstantiation,
1073 PDiag(diag::note_default_function_arg_instantiation_here)
1074 <<
OS.str() << Active->InstantiationRange);
1082 Name = std::string(
" '") + Parm->
getName().str() +
"'";
1086 TemplateParams =
Template->getTemplateParameters();
1090 ->getTemplateParameters();
1091 DiagFunc(Active->PointOfInstantiation,
1092 PDiag(diag::note_prior_template_arg_substitution)
1095 Active->TemplateArgs,
1096 Active->NumTemplateArgs)
1097 << Active->InstantiationRange);
1104 TemplateParams =
Template->getTemplateParameters();
1108 ->getTemplateParameters();
1110 DiagFunc(Active->PointOfInstantiation,
1111 PDiag(diag::note_template_default_arg_checking)
1113 Active->TemplateArgs,
1114 Active->NumTemplateArgs)
1115 << Active->InstantiationRange);
1120 DiagFunc(Active->PointOfInstantiation,
1121 PDiag(diag::note_evaluating_exception_spec_here)
1126 DiagFunc(Active->PointOfInstantiation,
1127 PDiag(diag::note_template_exception_spec_instantiation_here)
1129 << Active->InstantiationRange);
1133 DiagFunc(Active->PointOfInstantiation,
1134 PDiag(diag::note_template_requirement_instantiation_here)
1135 << Active->InstantiationRange);
1138 DiagFunc(Active->PointOfInstantiation,
1139 PDiag(diag::note_template_requirement_params_instantiation_here)
1140 << Active->InstantiationRange);
1144 DiagFunc(Active->PointOfInstantiation,
1145 PDiag(diag::note_nested_requirement_here)
1146 << Active->InstantiationRange);
1150 DiagFunc(Active->PointOfInstantiation,
1151 PDiag(diag::note_in_declaration_of_implicit_special_member)
1153 << Active->SpecialMember);
1158 Active->Entity->getLocation(),
1159 PDiag(diag::note_in_declaration_of_implicit_equality_comparison));
1165 auto *FD = dyn_cast<FunctionDecl>(Active->Entity);
1173 DiagFunc(Active->PointOfInstantiation,
1174 PDiag(diag::note_member_synthesized_at)
1176 <<
Context.getCanonicalTagType(MD->getParent()));
1178 QualType RecordType = FD->getParamDecl(0)
1180 .getNonReferenceType()
1181 .getUnqualifiedType();
1182 DiagFunc(Active->PointOfInstantiation,
1183 PDiag(diag::note_comparison_synthesized_at)
1190 DiagFunc(Active->Entity->getLocation(),
1191 PDiag(diag::note_rewriting_operator_as_spaceship));
1195 DiagFunc(Active->PointOfInstantiation,
1196 PDiag(diag::note_in_binding_decl_init)
1201 DiagFunc(Active->PointOfInstantiation,
1202 PDiag(diag::note_due_to_dllexported_class)
1208 DiagFunc(Active->PointOfInstantiation,
1209 PDiag(diag::note_building_builtin_dump_struct_call)
1212 Active->NumCallArgs)));
1219 DiagFunc(Active->PointOfInstantiation,
1220 PDiag(diag::note_lambda_substitution_here));
1223 unsigned DiagID = 0;
1224 if (!Active->Entity) {
1225 DiagFunc(Active->PointOfInstantiation,
1226 PDiag(diag::note_nested_requirement_here)
1227 << Active->InstantiationRange);
1231 DiagID = diag::note_concept_specialization_here;
1233 DiagID = diag::note_checking_constraints_for_template_id_here;
1235 DiagID = diag::note_checking_constraints_for_var_spec_id_here;
1237 DiagID = diag::note_checking_constraints_for_class_spec_id_here;
1240 DiagID = diag::note_checking_constraints_for_function_here;
1243 llvm::raw_svector_ostream
OS(TemplateArgsStr);
1246 printTemplateArgumentList(
OS, Active->template_arguments(),
1249 DiagFunc(Active->PointOfInstantiation,
1250 PDiag(DiagID) <<
OS.str() << Active->InstantiationRange);
1254 DiagFunc(Active->PointOfInstantiation,
1255 PDiag(diag::note_constraint_substitution_here)
1256 << Active->InstantiationRange);
1259 DiagFunc(Active->PointOfInstantiation,
1260 PDiag(diag::note_constraint_normalization_here)
1262 << Active->InstantiationRange);
1265 DiagFunc(Active->PointOfInstantiation,
1266 PDiag(diag::note_parameter_mapping_substitution_here)
1267 << Active->InstantiationRange);
1270 DiagFunc(Active->PointOfInstantiation,
1271 PDiag(diag::note_building_deduction_guide_here));
1278 if (Active->NumTemplateArgs == 0)
1280 DiagFunc(Active->PointOfInstantiation,
1281 PDiag(diag::note_template_type_alias_instantiation_here)
1283 << Active->InstantiationRange);
1286 DiagFunc(Active->PointOfInstantiation,
1287 PDiag(diag::note_template_arg_template_params_mismatch));
1290 DiagFunc(ParamLoc,
PDiag(diag::note_template_prev_declaration)
1292 << Active->InstantiationRange);
1300 return std::optional<TemplateDeductionInfo *>(
nullptr);
1305 Active != ActiveEnd;
1308 switch (Active->Kind) {
1323 return std::nullopt;
1330 return std::nullopt;
1352 assert(Active->DeductionInfo &&
"Missing deduction info pointer");
1353 return Active->DeductionInfo;
1364 return std::nullopt;
1378 if (Active->SavedInNonInstantiationSFINAEContext)
1379 return std::optional<TemplateDeductionInfo *>(
nullptr);
1382 return std::nullopt;
1390 class TemplateInstantiator :
public TreeTransform<TemplateInstantiator> {
1395 bool EvaluateConstraints =
true;
1398 bool IsIncomplete =
false;
1400 bool BailOutOnIncomplete;
1405 bool BuildPackExpansionTypes =
true;
1410 bool maybeInstantiateFunctionParameterToScope(
ParmVarDecl *OldParm);
1415 TemplateInstantiator(
Sema &SemaRef,
1418 bool BailOutOnIncomplete =
false)
1419 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
1420 Entity(Entity), BailOutOnIncomplete(BailOutOnIncomplete) {}
1422 void setEvaluateConstraints(
bool B) {
1423 EvaluateConstraints = B;
1425 bool getEvaluateConstraints() {
1426 return EvaluateConstraints;
1429 inline static struct ForParameterMappingSubstitution_t {
1430 } ForParameterMappingSubstitution;
1432 TemplateInstantiator(ForParameterMappingSubstitution_t, Sema &SemaRef,
1434 const MultiLevelTemplateArgumentList &TemplateArgs,
1435 bool BuildPackExpansionTypes)
1436 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
1437 BailOutOnIncomplete(
false),
1438 BuildPackExpansionTypes(BuildPackExpansionTypes) {}
1445 bool AlreadyTransformed(QualType
T);
1448 SourceLocation getBaseLocation() {
return Loc; }
1451 DeclarationName getBaseEntity() {
return Entity; }
1454 bool getIsIncomplete()
const {
return IsIncomplete; }
1458 void setBase(SourceLocation Loc, DeclarationName Entity) {
1460 this->Entity = Entity;
1463 unsigned TransformTemplateDepth(
unsigned Depth) {
1467 bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
1468 SourceRange PatternRange,
1469 ArrayRef<UnexpandedParameterPack> Unexpanded,
1470 bool FailOnPackProducingTemplates,
1471 bool &ShouldExpand,
bool &RetainExpansion,
1472 UnsignedOrNone &NumExpansions) {
1477 NamedDecl *VD = ParmPack.first.dyn_cast<NamedDecl *>();
1478 if (
auto *PVD = dyn_cast_if_present<ParmVarDecl>(VD);
1479 PVD && maybeInstantiateFunctionParameterToScope(PVD))
1484 return getSema().CheckParameterPacksForExpansion(
1485 EllipsisLoc, PatternRange, Unexpanded, TemplateArgs,
1486 FailOnPackProducingTemplates, ShouldExpand, RetainExpansion,
1490 void ExpandingFunctionParameterPack(ParmVarDecl *Pack) {
1494 TemplateArgument ForgetPartiallySubstitutedPack() {
1498 MultiLevelTemplateArgumentList &TemplateArgs =
1499 const_cast<MultiLevelTemplateArgumentList &
>(this->TemplateArgs);
1500 unsigned Depth, Index;
1503 Result = TemplateArgs(Depth, Index);
1504 TemplateArgs.
setArgument(Depth, Index, TemplateArgument());
1506 IsIncomplete =
true;
1507 if (BailOutOnIncomplete)
1508 return TemplateArgument();
1515 void RememberPartiallySubstitutedPack(TemplateArgument Arg) {
1521 MultiLevelTemplateArgumentList &TemplateArgs =
1522 const_cast<MultiLevelTemplateArgumentList &
>(this->TemplateArgs);
1523 unsigned Depth, Index;
1529 MultiLevelTemplateArgumentList ForgetSubstitution() {
1530 MultiLevelTemplateArgumentList
New;
1533 MultiLevelTemplateArgumentList Old =
1534 const_cast<MultiLevelTemplateArgumentList &
>(this->TemplateArgs);
1535 const_cast<MultiLevelTemplateArgumentList &
>(this->TemplateArgs) =
1540 void RememberSubstitution(MultiLevelTemplateArgumentList Old) {
1541 const_cast<MultiLevelTemplateArgumentList &
>(this->TemplateArgs) = Old;
1545 getTemplateArgumentPackPatternForRewrite(
const TemplateArgument &TA) {
1551 "unexpected pack arguments in template rewrite");
1560 Decl *TransformDecl(SourceLocation Loc, Decl *D);
1562 void transformAttrs(Decl *Old, Decl *
New) {
1566 void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> NewDecls) {
1568 (NewDecls.size() != 1 || !NewDecls.front()->isParameterPack())) {
1570 for (
auto *
New : NewDecls)
1576 assert(NewDecls.size() == 1 &&
1577 "should only have multiple expansions for a pack");
1583 auto *NewMD = dyn_cast<CXXMethodDecl>(
New);
1585 auto *OldMD = dyn_cast<CXXMethodDecl>(Old);
1586 if (
auto *NewTD = NewMD->getDescribedFunctionTemplate())
1587 NewTD->setInstantiatedFromMemberTemplate(
1588 OldMD->getDescribedFunctionTemplate());
1590 NewMD->setInstantiationOfMemberFunction(OldMD,
1598 if (
auto *DC = dyn_cast<DeclContext>(Old);
1599 DC && DC->isDependentContext() && DC->isFunctionOrMethod())
1605 Decl *TransformDefinition(SourceLocation Loc, Decl *D);
1609 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc);
1611 bool TransformExceptionSpec(SourceLocation Loc,
1612 FunctionProtoType::ExceptionSpecInfo &ESI,
1613 SmallVectorImpl<QualType> &Exceptions,
1618 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
1619 TypeSourceInfo *Declarator,
1620 SourceLocation StartLoc,
1621 SourceLocation NameLoc,
1622 IdentifierInfo *Name);
1626 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1627 TypeSourceInfo *TSInfo, QualType
T);
1630 TransformTemplateName(NestedNameSpecifierLoc &QualifierLoc,
1632 SourceLocation NameLoc,
1633 QualType ObjectType = QualType(),
1634 NamedDecl *FirstQualifierInScope =
nullptr,
1635 bool AllowInjectedClassName =
false);
1637 const AnnotateAttr *TransformAnnotateAttr(
const AnnotateAttr *AA);
1638 const CXXAssumeAttr *TransformCXXAssumeAttr(
const CXXAssumeAttr *AA);
1639 const LoopHintAttr *TransformLoopHintAttr(
const LoopHintAttr *LH);
1640 const NoInlineAttr *TransformStmtNoInlineAttr(
const Stmt *OrigS,
1642 const NoInlineAttr *A);
1643 const AlwaysInlineAttr *
1644 TransformStmtAlwaysInlineAttr(
const Stmt *OrigS,
const Stmt *InstS,
1645 const AlwaysInlineAttr *A);
1646 const CodeAlignAttr *TransformCodeAlignAttr(
const CodeAlignAttr *CA);
1647 const OpenACCRoutineDeclAttr *
1648 TransformOpenACCRoutineDeclAttr(
const OpenACCRoutineDeclAttr *A);
1649 ExprResult TransformPredefinedExpr(PredefinedExpr *E);
1650 ExprResult TransformDeclRefExpr(DeclRefExpr *E);
1651 ExprResult TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E);
1653 ExprResult TransformTemplateParmRefExpr(DeclRefExpr *E,
1654 NonTypeTemplateParmDecl *D);
1657 ExprResult RebuildVarDeclRefExpr(ValueDecl *PD, SourceLocation Loc);
1660 ExprResult TransformFunctionParmPackRefExpr(DeclRefExpr *E, ValueDecl *PD);
1665 ExprResult TransformFunctionParmPackExpr(FunctionParmPackExpr *E);
1667 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
1668 FunctionProtoTypeLoc TL) {
1670 return inherited::TransformFunctionProtoType(TLB, TL);
1673 QualType TransformTagType(TypeLocBuilder &TLB, TagTypeLoc TL) {
1674 auto Type = inherited::TransformTagType(TLB, TL);
1680 if (
const auto *ICNT = dyn_cast<InjectedClassNameType>(TL.
getTypePtr());
1683 Type = inherited::TransformType(
1684 ICNT->getOriginalDecl()->getCanonicalTemplateSpecializationType(
1692 bool TransformTemplateArgument(
const TemplateArgumentLoc &Input,
1693 TemplateArgumentLoc &Output,
1694 bool Uneval =
false) {
1695 const TemplateArgument &Arg = Input.
getArgument();
1696 std::vector<TemplateArgument> TArgs;
1706 pack, QualType(), SourceLocation{});
1707 TemplateArgumentLoc Output;
1708 if (TransformTemplateArgument(Input, Output, Uneval))
1713 TemplateArgument(llvm::ArrayRef(TArgs).copy(SemaRef.
Context)),
1714 QualType(), SourceLocation{});
1719 return inherited::TransformTemplateArgument(Input, Output, Uneval);
1723 ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
1724 UnsignedOrNone NumExpansions) {
1725 return inherited::RebuildPackExpansion(Pattern, EllipsisLoc,
1729 TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern,
1730 SourceLocation EllipsisLoc,
1731 UnsignedOrNone NumExpansions) {
1734 if (BuildPackExpansionTypes)
1735 return inherited::RebuildPackExpansion(Pattern, EllipsisLoc,
1742 TransformTemplateSpecializationType(TypeLocBuilder &TLB,
1743 TemplateSpecializationTypeLoc TL) {
1745 if (!getSema().ArgPackSubstIndex || !
T->
isSugared() ||
1755 QualType R = TransformType(
T->
desugar());
1760 UnsignedOrNone ComputeSizeOfPackExprWithoutSubstitution(
1761 ArrayRef<TemplateArgument> PackArgs) {
1772 return std::nullopt;
1774 return inherited::ComputeSizeOfPackExprWithoutSubstitution(PackArgs);
1777 template<
typename Fn>
1778 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
1779 FunctionProtoTypeLoc TL,
1780 CXXRecordDecl *ThisContext,
1781 Qualifiers ThisTypeQuals,
1782 Fn TransformExceptionSpec);
1784 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
1785 int indexAdjustment,
1786 UnsignedOrNone NumExpansions,
1787 bool ExpectParameterPack);
1789 using inherited::TransformTemplateTypeParmType;
1792 QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
1793 TemplateTypeParmTypeLoc TL,
1794 bool SuppressObjCLifetime);
1796 QualType BuildSubstTemplateTypeParmType(
1797 TypeLocBuilder &TLB,
bool SuppressObjCLifetime,
bool Final,
1798 Decl *AssociatedDecl,
unsigned Index, UnsignedOrNone PackIndex,
1799 TemplateArgument Arg, SourceLocation NameLoc);
1804 using inherited::TransformSubstTemplateTypeParmPackType;
1806 TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
1807 SubstTemplateTypeParmPackTypeLoc TL,
1808 bool SuppressObjCLifetime);
1810 TransformSubstBuiltinTemplatePackType(TypeLocBuilder &TLB,
1811 SubstBuiltinTemplatePackTypeLoc TL);
1814 ComputeLambdaDependency(LambdaScopeInfo *LSI) {
1816 TemplateInstArgsHelpers::getEnclosingTypeAliasTemplateDecl(
1818 TypeAlias && TemplateInstArgsHelpers::isLambdaEnclosedByTypeAliasDecl(
1820 unsigned TypeAliasDeclDepth =
TypeAlias.Template->getTemplateDepth();
1822 return CXXRecordDecl::LambdaDependencyKind::LDK_AlwaysDependent;
1823 for (
const TemplateArgument &TA :
TypeAlias.AssociatedTemplateArguments)
1825 return CXXRecordDecl::LambdaDependencyKind::LDK_AlwaysDependent;
1827 return inherited::ComputeLambdaDependency(LSI);
1835 LocalInstantiationScope Scope(SemaRef,
true,
1837 Sema::ConstraintEvalRAII<TemplateInstantiator> RAII(*
this);
1839 return inherited::TransformLambdaExpr(E);
1842 ExprResult TransformBlockExpr(BlockExpr *E) {
1843 LocalInstantiationScope Scope(SemaRef,
true,
1845 return inherited::TransformBlockExpr(E);
1848 ExprResult RebuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
1849 LambdaScopeInfo *LSI) {
1852 assert(PVD &&
"null in a parameter list");
1853 if (!PVD->hasDefaultArg())
1855 Expr *UninstExpr = PVD->getUninstantiatedDefaultArg();
1857 SourceLocation EqualLoc = UninstExpr->
getBeginLoc();
1866 PVD->setDefaultArg(ErrorResult.
get());
1869 return inherited::RebuildLambdaExpr(StartLoc, EndLoc, LSI);
1882 llvm::SaveAndRestore _(EvaluateConstraints,
true);
1883 return inherited::TransformLambdaBody(E, Body);
1887 LocalInstantiationScope Scope(SemaRef,
true);
1888 ExprResult TransReq = inherited::TransformRequiresExpr(E);
1891 assert(TransReq.
get() != E &&
1892 "Do not change value of isSatisfied for the existing expression. "
1893 "Create a new expression instead.");
1895 Sema::SFINAETrap Trap(SemaRef);
1900 if (Trap.hasErrorOccurred())
1906 bool TransformRequiresExprRequirements(
1907 ArrayRef<concepts::Requirement *> Reqs,
1908 SmallVectorImpl<concepts::Requirement *> &Transformed) {
1909 bool SatisfactionDetermined =
false;
1910 for (concepts::Requirement *Req : Reqs) {
1911 concepts::Requirement *TransReq =
nullptr;
1912 if (!SatisfactionDetermined) {
1913 if (
auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req))
1914 TransReq = TransformTypeRequirement(TypeReq);
1915 else if (
auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req))
1916 TransReq = TransformExprRequirement(ExprReq);
1918 TransReq = TransformNestedRequirement(
1928 SatisfactionDetermined =
true;
1931 Transformed.push_back(TransReq);
1936 TemplateParameterList *TransformTemplateParameterList(
1937 TemplateParameterList *OrigTPL) {
1938 if (!OrigTPL || !OrigTPL->
size())
return OrigTPL;
1941 TemplateDeclInstantiator DeclInstantiator(getSema(),
1942 Owner, TemplateArgs);
1943 DeclInstantiator.setEvaluateConstraints(EvaluateConstraints);
1944 return DeclInstantiator.SubstTemplateParams(OrigTPL);
1947 concepts::TypeRequirement *
1948 TransformTypeRequirement(concepts::TypeRequirement *Req);
1949 concepts::ExprRequirement *
1950 TransformExprRequirement(concepts::ExprRequirement *Req);
1951 concepts::NestedRequirement *
1952 TransformNestedRequirement(concepts::NestedRequirement *Req);
1954 SourceLocation KWLoc, SourceLocation RBraceLoc,
const RequiresExpr *RE,
1955 RequiresExprBodyDecl *Body, ArrayRef<ParmVarDecl *> Params,
1956 SmallVectorImpl<QualType> &PTypes,
1957 SmallVectorImpl<ParmVarDecl *> &TransParams,
1958 Sema::ExtParameterInfoBuilder &PInfos);
1962bool TemplateInstantiator::AlreadyTransformed(QualType
T) {
1970 getSema().MarkDeclarationsReferencedInType(Loc,
T);
1974Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
1978 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) {
1985 TTP->getPosition())) {
1986 IsIncomplete =
true;
1987 return BailOutOnIncomplete ?
nullptr : D;
1990 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
1992 if (TTP->isParameterPack()) {
1994 "Missing argument pack");
1995 Arg =
SemaRef.getPackSubstitutedTemplateArgument(Arg);
2000 "Wrong kind of template template argument");
2001 return Template.getAsTemplateDecl();
2008 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(D);
2009 PVD &&
SemaRef.CurrentInstantiationScope &&
2010 (
SemaRef.inConstraintSubstitution() ||
2011 SemaRef.inParameterMappingSubstitution()) &&
2012 maybeInstantiateFunctionParameterToScope(PVD))
2018bool TemplateInstantiator::maybeInstantiateFunctionParameterToScope(
2019 ParmVarDecl *OldParm) {
2020 if (
SemaRef.CurrentInstantiationScope->getInstantiationOfIfExists(OldParm))
2024 return !TransformFunctionTypeParam(OldParm, 0,
2028 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2032 PackExpansionTypeLoc ExpansionTL = TL.
castAs<PackExpansionTypeLoc>();
2034 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
2035 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
2037 bool ShouldExpand =
false;
2038 bool RetainExpansion =
false;
2039 UnsignedOrNone OrigNumExpansions =
2040 ExpansionTL.
getTypePtr()->getNumExpansions();
2041 UnsignedOrNone NumExpansions = OrigNumExpansions;
2043 Pattern.getSourceRange(), Unexpanded,
2045 ShouldExpand, RetainExpansion, NumExpansions))
2048 assert(ShouldExpand && !RetainExpansion &&
2049 "Shouldn't preserve pack expansion when evaluating constraints");
2050 ExpandingFunctionParameterPack(OldParm);
2051 for (
unsigned I = 0; I != *NumExpansions; ++I) {
2052 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
2053 if (!TransformFunctionTypeParam(OldParm, 0,
2061Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) {
2062 Decl *Inst = getSema().SubstDecl(D, getSema().
CurContext, TemplateArgs);
2066 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
2070bool TemplateInstantiator::TransformExceptionSpec(
2071 SourceLocation Loc, FunctionProtoType::ExceptionSpecInfo &ESI,
2072 SmallVectorImpl<QualType> &Exceptions,
bool &Changed) {
2077 return inherited::TransformExceptionSpec(Loc, ESI, Exceptions, Changed);
2081TemplateInstantiator::TransformFirstQualifierInScope(NamedDecl *D,
2082 SourceLocation Loc) {
2085 if (TemplateTypeParmDecl *TTPD = dyn_cast_or_null<TemplateTypeParmDecl>(D)) {
2086 const TemplateTypeParmType *TTP
2091 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getIndex());
2093 if (TTP->isParameterPack()) {
2095 "Missing argument pack");
2100 Arg =
SemaRef.getPackSubstitutedTemplateArgument(Arg);
2105 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
2107 if (
const TagType *Tag =
T->
getAs<TagType>())
2108 return Tag->getOriginalDecl();
2111 getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) <<
T;
2116 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
2120TemplateInstantiator::RebuildExceptionDecl(VarDecl *ExceptionDecl,
2121 TypeSourceInfo *Declarator,
2122 SourceLocation StartLoc,
2123 SourceLocation NameLoc,
2124 IdentifierInfo *Name) {
2125 VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
2126 StartLoc, NameLoc, Name);
2128 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
2132VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
2133 TypeSourceInfo *TSInfo,
2135 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo,
T);
2137 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
2141TemplateName TemplateInstantiator::TransformTemplateName(
2142 NestedNameSpecifierLoc &QualifierLoc, SourceLocation TemplateKWLoc,
2143 TemplateName Name, SourceLocation NameLoc, QualType ObjectType,
2144 NamedDecl *FirstQualifierInScope,
bool AllowInjectedClassName) {
2146 assert(!QualifierLoc &&
"Unexpected qualifier");
2149 TTP && TTP->getDepth() < TemplateArgs.
getNumLevels()) {
2155 TTP->getPosition())) {
2156 IsIncomplete =
true;
2160 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
2165 Arg = getTemplateArgumentPackPatternForRewrite(Arg);
2167 "unexpected nontype template argument kind in template rewrite");
2171 auto [AssociatedDecl, Final] =
2173 UnsignedOrNone PackIndex = std::nullopt;
2174 if (TTP->isParameterPack()) {
2176 "Missing argument pack");
2182 return getSema().Context.getSubstTemplateTemplateParmPack(
2183 Arg, AssociatedDecl, TTP->getIndex(), Final);
2186 PackIndex =
SemaRef.getPackIndex(Arg);
2187 Arg =
SemaRef.getPackSubstitutedTemplateArgument(Arg);
2191 assert(!
Template.isNull() &&
"Null template template argument");
2192 return getSema().Context.getSubstTemplateTemplateParm(
2193 Template, AssociatedDecl, TTP->getIndex(), PackIndex, Final);
2197 if (SubstTemplateTemplateParmPackStorage *SubstPack
2202 TemplateArgument Pack = SubstPack->getArgumentPack();
2204 SemaRef.getPackSubstitutedTemplateArgument(Pack).getAsTemplate();
2205 return getSema().Context.getSubstTemplateTemplateParm(
2206 Template, SubstPack->getAssociatedDecl(), SubstPack->getIndex(),
2207 SemaRef.getPackIndex(Pack), SubstPack->getFinal());
2210 return inherited::TransformTemplateName(
2211 QualifierLoc, TemplateKWLoc, Name, NameLoc, ObjectType,
2212 FirstQualifierInScope, AllowInjectedClassName);
2216TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) {
2224TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
2225 NonTypeTemplateParmDecl *NTTP) {
2232 IsIncomplete =
true;
2233 return BailOutOnIncomplete ?
ExprError() : E;
2241 Arg = getTemplateArgumentPackPatternForRewrite(Arg);
2243 "unexpected nontype template argument kind in template rewrite");
2249 auto [AssociatedDecl, Final] =
2251 UnsignedOrNone PackIndex = std::nullopt;
2254 "Missing argument pack");
2260 QualType TargetType =
SemaRef.SubstType(NTTP->
getType(), TemplateArgs,
2269 return new (
SemaRef.Context) SubstNonTypeTemplateParmPackExpr(
2273 PackIndex =
SemaRef.getPackIndex(Arg);
2274 Arg =
SemaRef.getPackSubstitutedTemplateArgument(Arg);
2276 return SemaRef.BuildSubstNonTypeTemplateParmExpr(
2277 AssociatedDecl, NTTP, E->
getLocation(), Arg, PackIndex, Final);
2281TemplateInstantiator::TransformAnnotateAttr(
const AnnotateAttr *AA) {
2282 SmallVector<Expr *> Args;
2283 for (Expr *Arg : AA->args()) {
2284 ExprResult Res = getDerived().TransformExpr(Arg);
2286 Args.push_back(Res.
get());
2288 return AnnotateAttr::CreateImplicit(getSema().
Context, AA->getAnnotation(),
2289 Args.data(), Args.size(), AA->getRange());
2292const CXXAssumeAttr *
2293TemplateInstantiator::TransformCXXAssumeAttr(
const CXXAssumeAttr *AA) {
2294 ExprResult Res = getDerived().TransformExpr(AA->getAssumption());
2298 if (!(Res.
get()->
getDependence() & ExprDependence::TypeValueInstantiation)) {
2299 Res = getSema().BuildCXXAssumeExpr(Res.
get(), AA->getAttrName(),
2305 return CXXAssumeAttr::CreateImplicit(getSema().
Context, Res.
get(),
2310TemplateInstantiator::TransformLoopHintAttr(
const LoopHintAttr *LH) {
2311 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).get();
2313 if (TransformedExpr == LH->getValue())
2318 LH->getSemanticSpelling() ==
2319 LoopHintAttr::Pragma_unroll))
2322 LoopHintAttr::OptionType Option = LH->getOption();
2323 LoopHintAttr::LoopHintState State = LH->getState();
2325 llvm::APSInt ValueAPS =
2328 if (ValueAPS.isZero() || ValueAPS.isOne()) {
2329 Option = LoopHintAttr::Unroll;
2330 State = LoopHintAttr::Disable;
2335 return LoopHintAttr::CreateImplicit(getSema().
Context, Option, State,
2336 TransformedExpr, *LH);
2338const NoInlineAttr *TemplateInstantiator::TransformStmtNoInlineAttr(
2339 const Stmt *OrigS,
const Stmt *InstS,
const NoInlineAttr *A) {
2345const AlwaysInlineAttr *TemplateInstantiator::TransformStmtAlwaysInlineAttr(
2346 const Stmt *OrigS,
const Stmt *InstS,
const AlwaysInlineAttr *A) {
2353const CodeAlignAttr *
2354TemplateInstantiator::TransformCodeAlignAttr(
const CodeAlignAttr *CA) {
2355 Expr *TransformedExpr = getDerived().TransformExpr(CA->getAlignment()).get();
2356 return getSema().BuildCodeAlignAttr(*CA, TransformedExpr);
2358const OpenACCRoutineDeclAttr *
2359TemplateInstantiator::TransformOpenACCRoutineDeclAttr(
2360 const OpenACCRoutineDeclAttr *A) {
2361 llvm_unreachable(
"RoutineDecl should only be a declaration attribute, as it "
2362 "applies to a Function Decl (and a few places for VarDecl)");
2365ExprResult TemplateInstantiator::RebuildVarDeclRefExpr(ValueDecl *PD,
2366 SourceLocation Loc) {
2367 DeclarationNameInfo NameInfo(PD->
getDeclName(), Loc);
2368 return getSema().BuildDeclarationNameExpr(CXXScopeSpec(), NameInfo, PD);
2372TemplateInstantiator::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
2376 ValueDecl *VD = cast_or_null<ValueDecl>(TransformDecl(E->
getExprLoc(), D));
2379 return RebuildVarDeclRefExpr(VD, E->
getExprLoc());
2382 QualType
T = TransformType(E->
getType());
2388 SmallVector<ValueDecl *, 8> Vars;
2392 ValueDecl *D = cast_or_null<ValueDecl>(TransformDecl(E->
getExprLoc(), *I));
2401 getSema().MarkFunctionParmPackReferenced(PackExpr);
2406TemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E,
2409 llvm::PointerUnion<Decl *, DeclArgumentPack *> *
Found
2410 = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
2411 assert(
Found &&
"no instantiation for parameter pack");
2413 Decl *TransformedDecl;
2414 if (DeclArgumentPack *Pack = dyn_cast<DeclArgumentPack *>(*
Found)) {
2418 QualType
T = TransformType(E->
getType());
2423 getSema().MarkFunctionParmPackReferenced(PackExpr);
2427 TransformedDecl = (*Pack)[*getSema().ArgPackSubstIndex];
2438TemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) {
2443 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
2445 return TransformTemplateParmRefExpr(E, NTTP);
2452 if (VarDecl *PD = dyn_cast<VarDecl>(D))
2454 return TransformFunctionParmPackRefExpr(E, PD);
2456 return inherited::TransformDeclRefExpr(E);
2459ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
2460 CXXDefaultArgExpr *E) {
2462 getDescribedFunctionTemplate() &&
2463 "Default arg expressions are never formed in dependent cases.");
2464 return SemaRef.BuildCXXDefaultArgExpr(
2469template<
typename Fn>
2470QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
2471 FunctionProtoTypeLoc TL,
2472 CXXRecordDecl *ThisContext,
2473 Qualifiers ThisTypeQuals,
2474 Fn TransformExceptionSpec) {
2482 LocalInstantiationScope *Current = getSema().CurrentInstantiationScope;
2483 std::optional<LocalInstantiationScope> Scope;
2487 return inherited::TransformFunctionProtoType(
2488 TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
2491ParmVarDecl *TemplateInstantiator::TransformFunctionTypeParam(
2492 ParmVarDecl *OldParm,
int indexAdjustment, UnsignedOrNone NumExpansions,
2493 bool ExpectParameterPack) {
2494 auto NewParm =
SemaRef.SubstParmVarDecl(
2495 OldParm, TemplateArgs, indexAdjustment, NumExpansions,
2496 ExpectParameterPack, EvaluateConstraints);
2497 if (NewParm &&
SemaRef.getLangOpts().OpenCL)
2498 SemaRef.deduceOpenCLAddressSpace(NewParm);
2502QualType TemplateInstantiator::BuildSubstTemplateTypeParmType(
2503 TypeLocBuilder &TLB,
bool SuppressObjCLifetime,
bool Final,
2504 Decl *AssociatedDecl,
unsigned Index, UnsignedOrNone PackIndex,
2505 TemplateArgument Arg, SourceLocation NameLoc) {
2510 if (SuppressObjCLifetime) {
2512 RQs = Replacement.getQualifiers();
2515 SemaRef.Context.getQualifiedType(Replacement.getUnqualifiedType(), RQs);
2519 QualType
Result = getSema().Context.getSubstTemplateTypeParmType(
2520 Replacement, AssociatedDecl, Index, PackIndex, Final);
2521 SubstTemplateTypeParmTypeLoc NewTL =
2522 TLB.
push<SubstTemplateTypeParmTypeLoc>(
Result);
2528TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
2529 TemplateTypeParmTypeLoc TL,
2530 bool SuppressObjCLifetime) {
2541 IsIncomplete =
true;
2542 if (BailOutOnIncomplete)
2545 TemplateTypeParmTypeLoc NewTL
2546 = TLB.
push<TemplateTypeParmTypeLoc>(TL.
getType());
2551 TemplateArgument Arg = TemplateArgs(
T->getDepth(),
T->getIndex());
2556 Arg = getTemplateArgumentPackPatternForRewrite(Arg);
2558 "unexpected nontype template argument kind in template rewrite");
2564 auto [AssociatedDecl, Final] =
2566 UnsignedOrNone PackIndex = std::nullopt;
2567 if (
T->isParameterPack()) {
2569 "Missing argument pack");
2575 QualType
Result = getSema().Context.getSubstTemplateTypeParmPackType(
2576 AssociatedDecl,
T->getIndex(), Final, Arg);
2577 SubstTemplateTypeParmPackTypeLoc NewTL
2578 = TLB.
push<SubstTemplateTypeParmPackTypeLoc>(
Result);
2584 PackIndex =
SemaRef.getPackIndex(Arg);
2585 Arg =
SemaRef.getPackSubstitutedTemplateArgument(Arg);
2589 "Template argument kind mismatch");
2591 return BuildSubstTemplateTypeParmType(TLB, SuppressObjCLifetime, Final,
2592 AssociatedDecl,
T->getIndex(),
2600 TemplateTypeParmDecl *NewTTPDecl =
nullptr;
2601 if (TemplateTypeParmDecl *OldTTPDecl =
T->getDecl())
2602 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
2604 QualType
Result = getSema().Context.getTemplateTypeParmType(
2606 T->isParameterPack(), NewTTPDecl);
2607 TemplateTypeParmTypeLoc NewTL = TLB.
push<TemplateTypeParmTypeLoc>(
Result);
2612QualType TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
2613 TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL,
2614 bool SuppressObjCLifetime) {
2615 const SubstTemplateTypeParmPackType *
T = TL.
getTypePtr();
2617 Decl *NewReplaced = TransformDecl(TL.
getNameLoc(),
T->getAssociatedDecl());
2622 if (NewReplaced !=
T->getAssociatedDecl())
2623 Result = getSema().Context.getSubstTemplateTypeParmPackType(
2624 NewReplaced,
T->getIndex(),
T->getFinal(),
T->getArgumentPack());
2625 SubstTemplateTypeParmPackTypeLoc NewTL =
2626 TLB.
push<SubstTemplateTypeParmPackTypeLoc>(
Result);
2631 TemplateArgument Pack =
T->getArgumentPack();
2632 TemplateArgument Arg =
SemaRef.getPackSubstitutedTemplateArgument(Pack);
2633 return BuildSubstTemplateTypeParmType(
2634 TLB, SuppressObjCLifetime,
T->getFinal(), NewReplaced,
T->getIndex(),
2638QualType TemplateInstantiator::TransformSubstBuiltinTemplatePackType(
2639 TypeLocBuilder &TLB, SubstBuiltinTemplatePackTypeLoc TL) {
2641 return TreeTransform::TransformSubstBuiltinTemplatePackType(TLB, TL);
2642 TemplateArgument
Result =
SemaRef.getPackSubstitutedTemplateArgument(
2646 return Result.getAsType();
2649static concepts::Requirement::SubstitutionDiagnostic *
2659 ErrorLoc = PDA.first;
2664 llvm::raw_svector_ostream
OS(Entity);
2668 C.backupStr(Entity), ErrorLoc,
C.backupStr(Message)};
2671concepts::Requirement::SubstitutionDiagnostic *
2674 llvm::raw_svector_ostream
OS(Entity);
2678 C.backupStr(Entity),
2679 Location, StringRef()};
2682ExprResult TemplateInstantiator::TransformRequiresTypeParams(
2696 if (getDerived().TransformFunctionTypeParams(
2697 KWLoc, Params,
nullptr,
nullptr, PTypes,
2698 &TransParams, PInfos, &ErrorIdx) ||
2699 Trap.hasErrorOccurred()) {
2705 SemaRef, Info, [&](llvm::raw_ostream &
OS) {
OS << *FailedDecl; })));
2706 return getDerived().RebuildRequiresExpr(KWLoc, Body, RE->
getLParenLoc(),
2708 TransReqs, RBraceLoc);
2714concepts::TypeRequirement *
2715TemplateInstantiator::TransformTypeRequirement(concepts::TypeRequirement *Req) {
2719 if (AlwaysRebuild())
2720 return RebuildTypeRequirement(
2725 Sema::SFINAETrap Trap(
SemaRef);
2727 Sema::InstantiatingTemplate TypeInst(
SemaRef,
2730 if (TypeInst.isInvalid())
2732 TypeSourceInfo *TransType = TransformType(Req->
getType());
2733 if (!TransType || Trap.hasErrorOccurred())
2735 [&] (llvm::raw_ostream&
OS) {
2738 return RebuildTypeRequirement(TransType);
2741concepts::ExprRequirement *
2742TemplateInstantiator::TransformExprRequirement(concepts::ExprRequirement *Req) {
2746 Sema::SFINAETrap Trap(
SemaRef);
2748 llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *>
2757 if (ExprInst.isInvalid())
2760 if (!TransExprRes.
isInvalid() && !Trap.hasErrorOccurred() &&
2762 TransExprRes =
SemaRef.CheckPlaceholderExpr(TransExprRes.
get());
2763 if (TransExprRes.
isInvalid() || Trap.hasErrorOccurred())
2768 TransExpr = TransExprRes.
get();
2771 std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;
2773 if (RetReq.isEmpty())
2774 TransRetReq.emplace();
2775 else if (RetReq.isSubstitutionFailure())
2776 TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
2777 else if (RetReq.isTypeConstraint()) {
2778 TemplateParameterList *OrigTPL =
2779 RetReq.getTypeConstraintTemplateParameterList();
2783 if (TPLInst.isInvalid())
2785 TemplateParameterList *TPL = TransformTemplateParameterList(OrigTPL);
2786 if (!TPL || Trap.hasErrorOccurred())
2788 [&] (llvm::raw_ostream&
OS) {
2789 RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()
2790 ->printPretty(
OS,
nullptr,
SemaRef.getPrintingPolicy());
2794 TransRetReq.emplace(TPL);
2797 assert(TransRetReq &&
"All code paths leading here must set TransRetReq");
2798 if (Expr *E = TransExpr.dyn_cast<Expr *>())
2800 std::move(*TransRetReq));
2801 return RebuildExprRequirement(
2806concepts::NestedRequirement *
2807TemplateInstantiator::TransformNestedRequirement(
2808 concepts::NestedRequirement *Req) {
2813 ConstraintSatisfaction Satisfaction;
2815 auto NestedReqWithDiag = [&
C,
this](Expr *E,
2816 ConstraintSatisfaction Satisfaction) {
2818 SmallString<128> Entity;
2819 llvm::raw_svector_ostream
OS(Entity);
2820 E->printPretty(
OS,
nullptr,
SemaRef.getPrintingPolicy());
2821 return new (
C) concepts::NestedRequirement(
2822 SemaRef.Context,
C.backupStr(Entity), std::move(Satisfaction));
2826 if (AlwaysRebuild())
2832 if (!getEvaluateConstraints()) {
2834 if (TransConstraint.
isInvalid() || !TransConstraint.
get())
2838 concepts::NestedRequirement(TransConstraint.
get());
2839 ConstraintSatisfaction Satisfaction;
2840 return new (
SemaRef.Context) concepts::NestedRequirement(
2841 SemaRef.Context, TransConstraint.
get(), Satisfaction);
2845 Expr *NewConstraint;
2846 TemplateDeductionInfo Info(Constraint->
getBeginLoc());
2851 Sema::InstantiatingTemplate ConstrInst(
2853 Sema::InstantiatingTemplate::ConstraintsCheck(),
2856 if (ConstrInst.isInvalid())
2859 Sema::SFINAETrap Trap(
SemaRef);
2862 Req, AssociatedConstraint(Constraint,
SemaRef.ArgPackSubstIndex),
2864 nullptr, &NewConstraint);
2866 assert(!
Success || !Trap.hasErrorOccurred() &&
2867 "Substitution failures must be handled "
2868 "by CheckConstraintSatisfaction.");
2872 return NestedReqWithDiag(Constraint, Satisfaction);
2876 if (!NewConstraint) {
2878 return NestedReqWithDiag(Constraint, Satisfaction);
2880 NewConstraint = Constraint;
2882 return new (
C) concepts::NestedRequirement(
C, NewConstraint, Satisfaction);
2889 bool AllowDeducedTST) {
2891 "Cannot perform an instantiation without some context on the "
2892 "instantiation stack");
2894 if (!
T->getType()->isInstantiationDependentType() &&
2895 !
T->getType()->isVariablyModifiedType())
2898 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
2899 return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(
T)
2900 : Instantiator.TransformType(
T);
2908 "Cannot perform an instantiation without some context on the "
2909 "instantiation stack");
2923 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
2937 bool *IsIncompleteSubstitution) {
2939 "Cannot perform an instantiation without some context on the "
2940 "instantiation stack");
2944 if (!
T->isInstantiationDependentType() && !
T->isVariablyModifiedType())
2947 TemplateInstantiator Instantiator(
2948 *
this, TemplateArgs, Loc, Entity,
2949 IsIncompleteSubstitution !=
nullptr);
2950 QualType QT = Instantiator.TransformType(
T);
2951 if (IsIncompleteSubstitution && Instantiator.getIsIncomplete())
2952 *IsIncompleteSubstitution =
true;
2957 if (
T->getType()->isInstantiationDependentType() ||
2958 T->getType()->isVariablyModifiedType())
2961 TypeLoc TL =
T->getTypeLoc().IgnoreParens();
2984 bool EvaluateConstraints) {
2986 "Cannot perform an instantiation without some context on the "
2987 "instantiation stack");
2992 TemplateInstantiator Instantiator(*
this, Args, Loc, Entity);
2993 Instantiator.setEvaluateConstraints(EvaluateConstraints);
3009 Result = Instantiator.TransformFunctionProtoType(
3010 TLB, Proto, ThisContext, ThisTypeQuals,
3012 bool &Changed) {
return false; });
3014 Result = Instantiator.TransformType(TLB, TL);
3028 bool Changed =
false;
3029 TemplateInstantiator Instantiator(*
this, Args, Loc,
DeclarationName());
3030 return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
3041 ESI, ExceptionStorage, Args))
3050 struct GetContainedInventedTypeParmVisitor :
3051 public TypeVisitor<GetContainedInventedTypeParmVisitor,
3052 TemplateTypeParmDecl *> {
3053 using TypeVisitor<GetContainedInventedTypeParmVisitor,
3059 return Visit(
T.getTypePtr());
3063 const TemplateTypeParmType *
T) {
3064 if (!
T->getDecl() || !
T->getDecl()->isImplicit())
3066 return T->getDecl();
3072 TemplateTypeParmDecl *VisitPointerType(
const PointerType *
T) {
3076 TemplateTypeParmDecl *VisitBlockPointerType(
const BlockPointerType *
T) {
3080 TemplateTypeParmDecl *VisitReferenceType(
const ReferenceType *
T) {
3081 return Visit(
T->getPointeeTypeAsWritten());
3084 TemplateTypeParmDecl *VisitMemberPointerType(
const MemberPointerType *
T) {
3088 TemplateTypeParmDecl *VisitArrayType(
const ArrayType *
T) {
3089 return Visit(
T->getElementType());
3092 TemplateTypeParmDecl *VisitDependentSizedExtVectorType(
3093 const DependentSizedExtVectorType *
T) {
3094 return Visit(
T->getElementType());
3097 TemplateTypeParmDecl *VisitVectorType(
const VectorType *
T) {
3098 return Visit(
T->getElementType());
3101 TemplateTypeParmDecl *VisitFunctionProtoType(
const FunctionProtoType *
T) {
3102 return VisitFunctionType(
T);
3105 TemplateTypeParmDecl *VisitFunctionType(
const FunctionType *
T) {
3109 TemplateTypeParmDecl *VisitParenType(
const ParenType *
T) {
3110 return Visit(
T->getInnerType());
3113 TemplateTypeParmDecl *VisitAttributedType(
const AttributedType *
T) {
3114 return Visit(
T->getModifiedType());
3117 TemplateTypeParmDecl *VisitMacroQualifiedType(
const MacroQualifiedType *
T) {
3118 return Visit(
T->getUnderlyingType());
3121 TemplateTypeParmDecl *VisitAdjustedType(
const AdjustedType *
T) {
3122 return Visit(
T->getOriginalType());
3125 TemplateTypeParmDecl *VisitPackExpansionType(
const PackExpansionType *
T) {
3126 return Visit(
T->getPattern());
3135 bool EvaluateConstraints) {
3142 Index =
SemaRef.ArgPackSubstIndex;
3171 bool ExpectParameterPack,
bool EvaluateConstraint) {
3191 }
else if (ExpectParameterPack) {
3197 diag::err_function_parameter_pack_without_parameter_packs)
3221 GetContainedInventedTypeParmVisitor().Visit(OldDI->
getType())) {
3223 auto *Inst = cast_or_null<TemplateTypeParmDecl>(
3228 if (Inst && !Inst->getTypeConstraint()) {
3297 "Cannot perform an instantiation without some context on the "
3298 "instantiation stack");
3300 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc,
3302 return Instantiator.TransformFunctionTypeParams(
3303 Loc, Params,
nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
3312 Expr *PatternExpr = Param->getUninstantiatedDefaultArg();
3321 Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;
3333 std::optional<LocalInstantiationScope> LIS;
3344 if (addInstantiatedParametersToScope(FD, PatternFD, *LIS, TemplateArgs))
3361 Param->getLocation(),
3366 Result = InitSeq.Perform(*
this, Entity, Kind, ResultE);
3396 auto ComputeInfo = [&S, &TemplateArgs, BaseSourceRange, BaseEllipsisLoc](
3403 if (IsLateExpansionAttempt) {
3408 return P.first.dyn_cast<
const SubstBuiltinTemplatePackType *>();
3410 if (!SawPackTypes) {
3422 BaseEllipsisLoc, BaseSourceRange, Unexpanded, TemplateArgs,
3427 if (ComputeInfo(
Base.getTypeSourceInfo(),
false, Info))
3431 Out =
Base.getTypeSourceInfo();
3441 if (!Out->getType()->containsUnexpandedParameterPack())
3446 if (ComputeInfo(Out,
true, Info))
3459 for (
const auto &
Base : Pattern->
bases()) {
3460 if (!
Base.getType()->isDependentType()) {
3462 if (RD->isInvalidDecl())
3471 if (
Base.isPackExpansion()) {
3483 ArgsForSubst = &EmptyList;
3498 Instantiation,
Base.getSourceRange(),
Base.isVirtual(),
3499 Base.getAccessSpecifierAsWritten(), Expanded,
3501 InstantiatedBases.push_back(InstantiatedBase);
3510 EllipsisLoc =
Base.getEllipsisLoc();
3518 Base.getSourceRange().getBegin(),
3529 Base.getSourceRange(),
3531 Base.getAccessSpecifierAsWritten(),
3534 InstantiatedBases.push_back(InstantiatedBase);
3566 Pattern, PatternDef, TSK, Complain))
3569 llvm::TimeTraceScope TimeScope(
"InstantiateClass", [&]() {
3570 llvm::TimeTraceMetadata M;
3571 llvm::raw_string_ostream
OS(M.Detail);
3574 if (llvm::isTimeTraceVerbose()) {
3577 M.Line =
SourceMgr.getExpansionLineNumber(Loc);
3582 Pattern = PatternDef;
3587 MSInfo->setTemplateSpecializationKind(TSK);
3588 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3590 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
3591 Spec->setTemplateSpecializationKind(TSK);
3592 Spec->setPointOfInstantiation(PointOfInstantiation);
3600 "instantiating class definition");
3618 SavePendingParsedClassStateRAII SavedPendingParsedClassState(*
this);
3644 bool MightHaveConstexprVirtualFunctions =
false;
3655 if (
Member->getDeclContext() != Pattern)
3666 if (
Member->isInvalidDecl()) {
3673 if (
FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
3674 Fields.push_back(Field);
3675 }
else if (
EnumDecl *
Enum = dyn_cast<EnumDecl>(NewMember)) {
3681 Enum->isCompleteDefinition()) {
3683 assert(MSInfo &&
"no spec info for member enum specialization");
3688 if (SA->isFailed()) {
3694 }
else if (
CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewMember)) {
3697 MightHaveConstexprVirtualFunctions =
true;
3718 if (ParsingClassDepth == 0)
3723 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
3724 E = LateAttrs.end(); I != E; ++I) {
3730 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
3732 ND->isCXXInstanceMember());
3737 I->NewDecl->addAttr(NewAttr);
3766 P->first, P->second)) {
3779 P->first, P->second)) {
3796 else if (MightHaveConstexprVirtualFunctions)
3801 Consumer.HandleTagDeclDefinition(Instantiation);
3813 Pattern, PatternDef, TSK,
true))
3815 Pattern = PatternDef;
3820 MSInfo->setTemplateSpecializationKind(TSK);
3821 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3830 "instantiating enum definition");
3865 "pattern and instantiation disagree about init style");
3873 Diag(PointOfInstantiation,
3874 diag::err_default_member_initializer_not_yet_parsed)
3875 << OutermostClass << Pattern;
3876 Diag(Pattern->getEndLoc(),
3877 diag::note_default_member_initializer_not_yet_parsed);
3887 Diag(PointOfInstantiation, diag::err_default_member_initializer_cycle)
3892 "instantiating default member init");
3900 PointOfInstantiation, Instantiation,
CurContext};
3916 L->DefaultMemberInitializerInstantiated(Instantiation);
3925 struct PartialSpecMatchResult {
3951 !CTPSD->getMostRecentDecl()->isMemberSpecialization())
3992 typedef PartialSpecMatchResult MatchResult;
3995 Template->getPartialSpecializations(PartialSpecs);
4008 if (
Template->getMostRecentDecl()->isMemberSpecialization() &&
4009 !Partial->getMostRecentDecl()->isMemberSpecialization())
4027 if (Matched.empty() && PrimaryStrictPackMatch)
4028 Matched = std::move(ExtraMatched);
4034 if (Matched.size() >= 1) {
4036 if (Matched.size() == 1) {
4049 PEnd = Matched.end();
4052 P->Partial, Best->Partial, PointOfInstantiation) ==
4061 PEnd = Matched.end();
4064 P->Partial, Best->Partial,
4065 PointOfInstantiation) != Best->Partial) {
4074 S.
Diag(PointOfInstantiation,
4075 diag::err_partial_spec_ordering_ambiguous)
4076 << ClassTemplateSpec;
4080 PEnd = Matched.end();
4082 S.
Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
4084 P->Partial->getTemplateParameters(), *P->Args);
4099 if (
auto *PartialSpec =
4102 while (PartialSpec->getInstantiatedFromMember()) {
4105 if (PartialSpec->isMemberSpecialization())
4108 PartialSpec = PartialSpec->getInstantiatedFromMember();
4110 Pattern = PartialSpec;
4113 while (
Template->getInstantiatedFromMemberTemplate()) {
4116 if (
Template->isMemberSpecialization())
4121 Pattern =
Template->getTemplatedDecl();
4131 bool PrimaryStrictPackMatch) {
4138 bool HadAvaibilityWarning =
4144 ClassTemplateSpec, TSK,
4145 PrimaryStrictPackMatch);
4151 PointOfInstantiation, ClassTemplateSpec, Pattern.
get(),
4158 if (!Err && !HadAvaibilityWarning) {
4178 "Unexpected template specialization kind!");
4179 for (
auto *D : Instantiation->
decls()) {
4180 bool SuppressNew =
false;
4181 if (
auto *
Function = dyn_cast<FunctionDecl>(D)) {
4183 Function->getInstantiatedFromMemberFunction()) {
4185 if (
Function->getTrailingRequiresClause()) {
4193 if (
Function->hasAttr<ExcludeFromExplicitInstantiationAttr>())
4197 Function->getTemplateSpecializationKind();
4202 PointOfInstantiation, TSK,
Function, PrevTSK,
4203 Function->getPointOfInstantiation(), SuppressNew) ||
4216 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
4226 std::make_pair(
Function, PointOfInstantiation));
4229 }
else if (
auto *Var = dyn_cast<VarDecl>(D)) {
4234 if (Var->
hasAttr<ExcludeFromExplicitInstantiationAttr>())
4238 assert(MSInfo &&
"No member specialization information?");
4267 }
else if (
auto *
Record = dyn_cast<CXXRecordDecl>(D)) {
4268 if (
Record->hasAttr<ExcludeFromExplicitInstantiationAttr>())
4276 if (
Record->isInjectedClassName() ||
Record->getPreviousDecl() ||
4281 assert(MSInfo &&
"No member specialization information?");
4287 if (
Context.getTargetInfo().getTriple().isOSWindows() &&
4307 assert(Pattern &&
"Missing instantiated-from-template information");
4309 if (!
Record->getDefinition()) {
4330 Record->getTemplateSpecializationKind() ==
4332 Record->setTemplateSpecializationKind(TSK);
4337 Pattern = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
4341 }
else if (
auto *
Enum = dyn_cast<EnumDecl>(D)) {
4343 assert(MSInfo &&
"No member specialization information?");
4350 PointOfInstantiation, TSK,
Enum,
4356 if (
Enum->getDefinition())
4359 EnumDecl *Pattern =
Enum->getTemplateInstantiationPattern();
4360 assert(Pattern &&
"Missing instantiated-from-template information");
4371 }
else if (
auto *Field = dyn_cast<FieldDecl>(D)) {
4382 ClassPattern->
lookup(Field->getDeclName());
4415 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4418 return Instantiator.TransformStmt(S);
4426 TemplateInstantiator Instantiator(*
this, TemplateArgs, Loc, Entity);
4427 return Instantiator.TransformTemplateArgument(Input, Output);
4434 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4436 return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(), Out);
4443 TemplateInstantiator Instantiator(
4444 TemplateInstantiator::ForParameterMappingSubstitution, *
this, BaseLoc,
4445 TemplateArgs, BuildPackExpansionTypes);
4446 return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(), Out);
4454 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4457 return Instantiator.TransformExpr(E);
4466 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4468 return Instantiator.TransformAddressOfOperand(E);
4484 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4486 Instantiator.setEvaluateConstraints(
false);
4487 return Instantiator.TransformExpr(E);
4492 bool CXXDirectInit) {
4493 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4495 return Instantiator.TransformInitializer(
Init, CXXDirectInit);
4504 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4507 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
4517 TemplateInstantiator Instantiator(*
this, TemplateArgs, NNS.
getBeginLoc(),
4519 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
4525 TemplateInstantiator Instantiator(*
this, TemplateArgs, NameInfo.
getLoc(),
4527 return Instantiator.TransformDeclarationNameInfo(NameInfo);
4535 TemplateInstantiator Instantiator(*
this, TemplateArgs, NameLoc,
4537 return Instantiator.TransformTemplateName(QualifierLoc, TemplateKWLoc, Name,
4546 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
4547 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
4548 unsigned i = PV->getFunctionScopeIndex();
4551 if (i < FD->getNumParams() && FD->getParamDecl(i) == PV)
4552 return FD->getCanonicalDecl()->getParamDecl(i);
4558llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
4562 Current = Current->Outer) {
4565 const Decl *CheckD = D;
4567 LocalDeclsMap::iterator
Found = Current->LocalDecls.find(CheckD);
4568 if (
Found != Current->LocalDecls.end())
4569 return &
Found->second;
4573 if (
const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
4580 if (!Current->CombineWithOuterScope)
4587llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
4600 if (RD->isLocalClass())
4617 assert(
isa<LabelDecl>(D) &&
"declaration not instantiated in this scope");
4623 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
4624 if (Stored.isNull()) {
4628 while (Current->CombineWithOuterScope && Current->Outer) {
4629 Current = Current->Outer;
4630 assert(!Current->LocalDecls.contains(D) &&
4631 "Instantiated local in inner and outer scopes");
4635 }
else if (
DeclArgumentPack *Pack = dyn_cast<DeclArgumentPack *>(Stored)) {
4638 assert(
cast<Decl *>(Stored) == Inst &&
"Already instantiated this local");
4646 Pack->push_back(Inst);
4653 Current && Current->CombineWithOuterScope; Current = Current->Outer)
4654 assert(!Current->LocalDecls.contains(D) &&
4655 "Creating local pack after instantiation of local");
4659 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
4662 ArgumentPacks.push_back(Pack);
4667 if (llvm::is_contained(*Pack, D))
4674 unsigned NumExplicitArgs) {
4675 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
4676 "Already have a partially-substituted pack");
4677 assert((!PartiallySubstitutedPack
4678 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
4679 "Wrong number of arguments in partially-substituted pack");
4680 PartiallySubstitutedPack = Pack;
4681 ArgsInPartiallySubstitutedPack = ExplicitArgs;
4682 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
4687 unsigned *NumExplicitArgs)
const {
4689 *ExplicitArgs =
nullptr;
4690 if (NumExplicitArgs)
4691 *NumExplicitArgs = 0;
4694 Current = Current->Outer) {
4695 if (Current->PartiallySubstitutedPack) {
4697 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
4698 if (NumExplicitArgs)
4699 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
4701 return Current->PartiallySubstitutedPack;
4704 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.
This file defines the classes used to store parsed information about declaration-specifiers and decla...
Defines the C++ template declaration subclasses.
Defines Expressions and AST nodes for C++2a concepts.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Record Record
static TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, ArrayRef< TemplateArgument > Ps, ArrayRef< TemplateArgument > As, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, bool NumberOfArgumentsMustMatch, bool PartialOrdering, PackFold PackFold, bool *HasDeducedAnyParam)
static bool PreparePackForExpansion(Sema &S, const CXXBaseSpecifier &Base, const MultiLevelTemplateArgumentList &TemplateArgs, TypeSourceInfo *&Out, UnexpandedInfo &Info)
static const Decl * getCanonicalParmVarDecl(const Decl *D)
static ActionResult< CXXRecordDecl * > getPatternForClassTemplateSpecialization(Sema &S, SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool PrimaryStrictPackMatch)
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)
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
const clang::PrintingPolicy & getPrintingPolicy() const
The result of parsing/analyzing an expression, statement etc.
Attr - This represents one attribute.
Represents a base class of a C++ class.
SourceLocation getUsedLocation() const
Retrieve the location where this default argument was actually used.
const ParmVarDecl * getParam() const
Represents a static or instance method of a struct/union/class.
Represents a C++ struct/union/class.
Decl * getLambdaContextDecl() const
Retrieve the declaration that provides additional context for a lambda, when the normal declaration c...
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
bool isLambda() const
Determine whether this class describes a lambda function object.
CXXRecordDecl * getDefinition() const
unsigned getNumBases() const
Retrieves the number of base classes of this class.
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
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.
Declaration of a class template.
ClassTemplateDecl * getMostRecentDecl()
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations() const
Retrieve the set of partial specializations of this class template.
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
const TypeClass * getTypePtr() 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)
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
bool isFileContext() const
DeclContextLookupResult lookup_result
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.
SourceLocation getLocation() const
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
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).
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.
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
NestedNameSpecifier getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
TypeSourceInfo * getTypeSourceInfo() const
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,...
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
EnumDecl * getDefinition() const
This represents one expression.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
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.
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.
static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, ValueDecl *ParamPack, SourceLocation NameLoc, ArrayRef< ValueDecl * > Params)
ValueDecl * getExpansion(unsigned I) const
Get an expansion of the parameter pack by index.
ValueDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
ValueDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
unsigned getNumExpansions() const
Get the number of parameters in this parameter pack.
SourceLocation getParameterPackLocation() const
Get the location of the parameter pack.
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...
QualType getReturnType() const
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 an entity that is being initialized.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
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...
LocalInstantiationScope(Sema &SemaRef, bool CombineWithOuterScope=false, bool InstantiatingLambdaOrBlock=false)
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.
SmallVector< ValueDecl *, 4 > DeclArgumentPack
A set of declarations.
llvm::PointerUnion< Decl *, DeclArgumentPack * > * getInstantiationOfIfExists(const Decl *D)
Similar to findInstantiationOf(), but it wouldn't assert if the instantiation was not found within th...
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)
bool isLambdaOrBlock() const
Determine whether this scope is for instantiating a lambda or block.
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.
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>::".
const Type * getAsType() const
@ Type
A type, stored as a Type*.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
unsigned getDepth() const
Get the nesting depth of the template parameter.
SourceLocation getEllipsisLoc() const
TypeLoc getPatternLoc() const
Represents a parameter to a function.
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
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)
PredefinedIdentKind getIdentKind() const
SourceLocation getLocation() const
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
A (possibly-)qualified type.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
void addConst()
Add the const type qualifier to this QualType.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
The collection of all-type qualifiers we support.
void removeObjCLifetime()
Represents a struct/union/class.
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Represents the body of a requires-expression.
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
RequiresExprBodyDecl * getBody() const
Scope - A scope is a transient data structure that is used while parsing the program.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial 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.
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)
llvm::function_ref< void(SourceLocation, PartialDiagnostic)> InstantiationContextDiagFuncRef
TemplateName SubstTemplateName(SourceLocation TemplateKWLoc, NestedNameSpecifierLoc &QualifierLoc, TemplateName Name, SourceLocation NameLoc, const MultiLevelTemplateArgumentList &TemplateArgs)
ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, UnsignedOrNone NumExpansions, bool ExpectParameterPack, bool EvaluateConstraints=true)
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 ...
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...
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 InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain, bool PrimaryStrictPackMatch)
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
ExprResult SubstConstraintExprWithoutSatisfaction(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
void PrintInstantiationStack()
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.
SmallVector< LateInstantiatedAttribute, 1 > LateInstantiatedAttrVec
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool pushCodeSynthesisContext(CodeSynthesisContext Ctx)
bool SubstTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentListInfo &Outputs)
Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, TranslationUnitKind TUKind=TU_Complete, CodeCompleteConsumer *CompletionConsumer=nullptr)
void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
const LangOptions & getLangOpts() const
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
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).
TemplateArgument getPackSubstitutedTemplateArgument(TemplateArgument Arg) const
void popCodeSynthesisContext()
bool usesPartialOrExplicitSpecialization(SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec)
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...
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...
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 inConstraintSubstitution() const
Determine whether we are currently performing constraint substitution.
bool CheckAlwaysInlineAttr(const Stmt *OrigSt, const Stmt *CurSt, const AttributeCommonInfo &A)
void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass, bool ObjCPropertyAccess, bool AvoidPartialAvailabilityChecks, ObjCInterfaceDecl *ClassReceiver)
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, TemplateDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
std::pair< AvailabilityResult, const NamedDecl * > ShouldDiagnoseAvailabilityOfDecl(const NamedDecl *D, std::string *Message, ObjCInterfaceDecl *ClassReceiver)
The diagnostic we should emit for D, and the declaration that originated it, or AR_Available.
bool InstantiateInClassInitializer(SourceLocation PointOfInstantiation, FieldDecl *Instantiation, FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the definition of a field from the given pattern.
UnsignedOrNone ArgPackSubstIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
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)
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
unsigned LastEmittedCodeSynthesisContextDepth
The depth of the context stack at the point when the most recent error or warning was produced.
bool inParameterMappingSubstitution() const
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.
bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation, NamedDecl *Instantiation, bool InstantiatedFromMember, const NamedDecl *Pattern, const NamedDecl *PatternDef, TemplateSpecializationKind TSK, bool Complain=true, bool *Unreachable=nullptr)
Determine whether we would be unable to instantiate this template (because it either has no definitio...
SourceManager & SourceMgr
bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool FailOnPackProducingTemplates, bool &ShouldExpand, bool &RetainExpansion, UnsignedOrNone &NumExpansions)
Determine whether we could expand a pack expansion with the given set of parameter packs into separat...
DiagnosticsEngine & Diags
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier * > Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
friend class InitializationSequence
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.
bool SubstTemplateArgumentsInParameterMapping(ArrayRef< TemplateArgumentLoc > Args, SourceLocation BaseLoc, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentListInfo &Out, bool BuildPackExpansionTypes)
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)
ExprResult SubstCXXIdExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
Substitute an expression as if it is a address-of-operand, which makes it act like a CXXIdExpression ...
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments.
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)
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, UnsignedOrNone NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
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.
bool isValid() const
Return true if this is a valid SourceLocation object.
A trivial tuple used to represent a source range.
SourceLocation getBegin() const
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 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.
void startDefinition()
Starts the definition of this tag declaration.
TagKind getTagKind() const
void setBraceRange(SourceRange R)
SourceLocation getNameLoc() const
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.
@ 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.
@ 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()
SmallVectorImpl< std::pair< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > >::iterator delayed_partial_spec_iterator
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)
LocalInstantiationScope * getStartingScope() const
VarTemplatePartialSpecializationDecl * InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a variable template partial specialization.
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
SmallVectorImpl< std::pair< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > >::iterator delayed_var_partial_spec_iterator
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.
@ Template
A single template declaration.
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
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.
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.
void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint, UnsignedOrNone ArgPackSubstIndex)
bool isParameterPack() const
Returns whether this is a parameter pack.
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
UnsignedOrNone getArgPackSubstIndex() const
Expr * getImmediatelyDeclaredConstraint() const
Get the immediately-declared constraint expression introduced by this type-constraint,...
const NestedNameSpecifierLoc & getNestedNameSpecifierLoc() const
TemplateDecl * getNamedConcept() 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 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)
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 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
bool isParameterPack() const
Determine whether this value is actually a function parameter pack, init-capture pack,...
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.
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.
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...
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?
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
bool hasStrictPackMatch() const
Defines the clang::TargetInfo interface.
std::variant< struct RequiresDecl, struct HeaderDecl, struct UmbrellaDirDecl, struct ModuleDecl, struct ExcludeDecl, struct ExportDecl, struct ExportAsDecl, struct ExternModuleDecl, struct UseDecl, struct LinkDecl, struct ConfigMacrosDecl, struct ConflictDecl > Decl
All declarations that can appear in a module declaration.
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)
bool isa(CodeGen::Address addr)
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ TemplateName
The identifier is a template name. FIXME: Add an annotation for that.
NamedDecl * getAsNamedDecl(TemplateParameter P)
std::pair< llvm::PointerUnion< const TemplateTypeParmType *, NamedDecl *, const TemplateSpecializationType *, const SubstBuiltinTemplatePackType * >, SourceLocation > UnexpandedParameterPack
bool isPackProducingBuiltinTemplateName(TemplateName N)
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
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.
const FunctionProtoType * T
@ Template
We are parsing a template declaration.
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...
@ Type
The name was classified as a type.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
@ 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.
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
DynamicRecursiveASTVisitorBase< false > DynamicRecursiveASTVisitor
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.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
U cast(CodeGen::Address addr)
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
ActionResult< Expr * > ExprResult
@ EST_Uninstantiated
not instantiated yet
@ EST_None
no exception specification
ActionResult< Stmt * > StmtResult
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 ('<').
ArrayRef< TemplateArgumentLoc > arguments() const
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
Holds information about the various types of exception specification.
ExceptionSpecificationType Type
The kind of exception specification this is.
ExceptionSpecInfo ExceptionSpec
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
SourceRange InstantiationRange
The source range that covers the construct that cause the instantiation, e.g., the template-id that c...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
bool SavedInNonInstantiationSFINAEContext
Was the enclosing context a non-instantiation SFINAE context?
const TemplateArgument * TemplateArgs
The list of template arguments we are substituting, if they are not part of the entity.
sema::TemplateDeductionInfo * DeductionInfo
The template deduction info object associated with the substitution or checking of explicit or deduce...
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)
bool ExpandUnderForgetSubstitions
UnsignedOrNone NumExpansions