39#include "llvm/ADT/STLForwardCompat.h"
40#include "llvm/ADT/StringExtras.h"
41#include "llvm/Support/ErrorHandling.h"
42#include "llvm/Support/TimeProfiler.h"
55 const Decl *NextDecl =
nullptr;
57 bool ClearRelativeToPrimary =
true;
58 static Response Done() {
63 static Response ChangeDecl(
const Decl *ND) {
68 static Response ChangeDecl(
const DeclContext *Ctx) {
74 static Response UseNextDecl(
const Decl *CurDecl) {
78 static Response DontClearRelativeToPrimaryNextDecl(
const Decl *CurDecl) {
79 Response R = Response::UseNextDecl(CurDecl);
80 R.ClearRelativeToPrimary =
false;
89getPrimaryTemplateOfGenericLambda(
const FunctionDecl *LambdaCallOperator) {
91 if (
auto *FTD = dyn_cast_if_present<FunctionTemplateDecl>(
93 FTD && FTD->getInstantiatedFromMemberTemplate()) {
95 FTD->getInstantiatedFromMemberTemplate()->getTemplatedDecl();
96 }
else if (
auto *Prev = cast<CXXMethodDecl>(LambdaCallOperator)
97 ->getInstantiatedFromMemberFunction())
98 LambdaCallOperator = Prev;
102 return LambdaCallOperator;
105struct EnclosingTypeAliasTemplateDetails {
110 explicit operator bool()
noexcept {
return Template; }
115EnclosingTypeAliasTemplateDetails
116getEnclosingTypeAliasTemplateDecl(
Sema &SemaRef) {
119 TypeAliasTemplateInstantiation)
121 EnclosingTypeAliasTemplateDetails Result;
122 auto *TATD = cast<TypeAliasTemplateDecl>(CSC.Entity),
123 *Next = TATD->getInstantiatedFromMemberTemplate();
127 CSC.template_arguments(),
130 Result.PrimaryTypeAliasDecl = Next;
131 Next = Next->getInstantiatedFromMemberTemplate();
148bool isLambdaEnclosedByTypeAliasDecl(
151 return cast<CXXRecordDecl>(PrimaryLambdaCallOperator->
getDeclContext())
155 const_cast<FunctionDecl *
>(PrimaryLambdaCallOperator)) ==
163 bool SkipForSpecialization) {
167 return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);
171 !isa<VarTemplatePartialSpecializationDecl>(VarTemplSpec))
172 return Response::Done();
177 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
181 if (!SkipForSpecialization)
182 Result.addOuterTemplateArguments(
185 if (Partial->isMemberSpecialization())
186 return Response::Done();
189 if (!SkipForSpecialization)
190 Result.addOuterTemplateArguments(
194 return Response::Done();
196 return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);
208 for (
unsigned I = 0, N = TTP->
getDepth() + 1; I != N; ++I)
209 Result.addOuterTemplateArguments(std::nullopt);
210 return Response::Done();
213Response HandlePartialClassTemplateSpec(
216 if (!SkipForSpecialization)
218 return Response::Done();
225 bool SkipForSpecialization) {
229 !isa<ClassTemplatePartialSpecializationDecl>(ClassTemplSpec))
230 return Response::Done();
232 if (!SkipForSpecialization)
233 Result.addOuterTemplateArguments(
242 return Response::Done();
250 return Response::ChangeDecl(InstFromPartialTempl->getLexicalDeclContext());
252 return Response::UseNextDecl(ClassTemplSpec);
258 bool ForConstraintInstantiation) {
260 if (!RelativeToPrimary &&
261 Function->getTemplateSpecializationKindForInstantiation() ==
263 return Response::Done();
265 if (!RelativeToPrimary &&
270 return Response::UseNextDecl(
Function);
272 Function->getTemplateSpecializationArgs()) {
275 TemplateArgs->asArray(),
278 if (RelativeToPrimary &&
279 (
Function->getTemplateSpecializationKind() ==
282 !
Function->getPrimaryTemplate()->getFriendObjectKind())))
283 return Response::UseNextDecl(
Function);
287 assert(
Function->getPrimaryTemplate() &&
"No function template?");
288 if (
Function->getPrimaryTemplate()->isMemberSpecialization())
289 return Response::Done();
292 if (!ForConstraintInstantiation &&
301 if (
auto TypeAlias = getEnclosingTypeAliasTemplateDecl(SemaRef)) {
302 if (isLambdaEnclosedByTypeAliasDecl(
303 getPrimaryTemplateOfGenericLambda(
305 TypeAlias.PrimaryTypeAliasDecl))
306 return Response::UseNextDecl(
Function);
308 return Response::Done();
311 }
else if (
Function->getDescribedFunctionTemplate()) {
313 (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
314 "Outer template not instantiated?");
321 Function->getNonTransparentDeclContext()->isFileContext() &&
323 return Response::ChangeDecl(
Function->getLexicalDeclContext());
326 if (ForConstraintInstantiation &&
Function->getFriendObjectKind())
327 return Response::ChangeDecl(
Function->getLexicalDeclContext());
328 return Response::UseNextDecl(
Function);
333 if (!isa<ClassTemplateSpecializationDecl>(FTD->
getDeclContext())) {
334 Result.addOuterTemplateArguments(
362 if (TSTy->isCurrentInstantiation()) {
363 auto *RD = TSTy->getCanonicalTypeInternal()->getAsCXXRecordDecl();
365 Arguments = CTD->getInjectedTemplateArgs();
367 dyn_cast<ClassTemplateSpecializationDecl>(RD))
371 Result.addOuterTemplateArguments(
387 bool ForConstraintInstantiation) {
390 (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
391 "Outer template not instantiated?");
392 if (ClassTemplate->isMemberSpecialization())
393 return Response::Done();
394 if (ForConstraintInstantiation)
395 Result.addOuterTemplateArguments(
const_cast<CXXRecordDecl *
>(Rec),
396 ClassTemplate->getInjectedTemplateArgs(),
403 return Response::Done();
408 if (ForConstraintInstantiation && IsFriend &&
417 return Response::ChangeDecl(LCD);
421 if (
auto TypeAlias = getEnclosingTypeAliasTemplateDecl(SemaRef)) {
424 if (isLambdaEnclosedByTypeAliasDecl(PrimaryLambdaCallOperator,
425 TypeAlias.PrimaryTypeAliasDecl)) {
426 Result.addOuterTemplateArguments(TypeAlias.Template,
427 TypeAlias.AssociatedTemplateArguments,
442 return Response::ChangeDecl(TypeAlias.Template->getDeclContext());
447 return Response::UseNextDecl(Rec);
450Response HandleImplicitConceptSpecializationDecl(
453 Result.addOuterTemplateArguments(
457 return Response::UseNextDecl(CSD);
460Response HandleGenericDeclContext(
const Decl *CurDecl) {
461 return Response::UseNextDecl(CurDecl);
497 const FunctionDecl *Pattern,
bool ForConstraintInstantiation,
498 bool SkipForSpecialization) {
499 assert((ND || DC) &&
"Can't find arguments for a decl if one isn't provided");
504 const Decl *CurDecl = ND;
510 Result.addOuterTemplateArguments(
const_cast<NamedDecl *
>(ND), *Innermost,
520 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl))
521 HandleDefaultTempArgIntoTempTempParam(TTP,
Result);
522 CurDecl = Response::UseNextDecl(CurDecl).NextDecl;
527 if (
const auto *VarTemplSpec =
528 dyn_cast<VarTemplateSpecializationDecl>(CurDecl)) {
529 R = HandleVarTemplateSpec(VarTemplSpec,
Result, SkipForSpecialization);
530 }
else if (
const auto *PartialClassTemplSpec =
531 dyn_cast<ClassTemplatePartialSpecializationDecl>(CurDecl)) {
532 R = HandlePartialClassTemplateSpec(PartialClassTemplSpec,
Result,
533 SkipForSpecialization);
534 }
else if (
const auto *ClassTemplSpec =
535 dyn_cast<ClassTemplateSpecializationDecl>(CurDecl)) {
536 R = HandleClassTemplateSpec(ClassTemplSpec,
Result,
537 SkipForSpecialization);
538 }
else if (
const auto *
Function = dyn_cast<FunctionDecl>(CurDecl)) {
539 R = HandleFunction(*
this,
Function,
Result, Pattern, RelativeToPrimary,
540 ForConstraintInstantiation);
541 }
else if (
const auto *Rec = dyn_cast<CXXRecordDecl>(CurDecl)) {
543 ForConstraintInstantiation);
544 }
else if (
const auto *CSD =
545 dyn_cast<ImplicitConceptSpecializationDecl>(CurDecl)) {
546 R = HandleImplicitConceptSpecializationDecl(CSD,
Result);
547 }
else if (
const auto *FTD = dyn_cast<FunctionTemplateDecl>(CurDecl)) {
548 R = HandleFunctionTemplateDecl(FTD,
Result);
549 }
else if (
const auto *CTD = dyn_cast<ClassTemplateDecl>(CurDecl)) {
550 R = Response::ChangeDecl(CTD->getLexicalDeclContext());
551 }
else if (!isa<DeclContext>(CurDecl)) {
552 R = Response::DontClearRelativeToPrimaryNextDecl(CurDecl);
553 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl)) {
554 R = HandleDefaultTempArgIntoTempTempParam(TTP,
Result);
557 R = HandleGenericDeclContext(CurDecl);
562 if (R.ClearRelativeToPrimary)
563 RelativeToPrimary =
false;
565 CurDecl = R.NextDecl;
608 llvm_unreachable(
"Invalid SynthesisKind!");
638 AlreadyInstantiating = !Inst.Entity ?
false :
640 .insert({Inst.Entity->getCanonicalDecl(), Inst.Kind})
651 PointOfInstantiation, InstantiationRange, Entity) {}
658 PointOfInstantiation, InstantiationRange, Entity) {}
668 Template, TemplateArgs) {}
678 TemplateArgs, &DeductionInfo) {
692 PointOfInstantiation, InstantiationRange, Template, nullptr,
693 TemplateArgs, &DeductionInfo) {}
703 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
704 TemplateArgs, &DeductionInfo) {}
714 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
715 TemplateArgs, &DeductionInfo) {}
723 PointOfInstantiation, InstantiationRange, Param, nullptr,
733 PointOfInstantiation, InstantiationRange, Param, Template,
743 PointOfInstantiation, InstantiationRange, Param, Template,
752 PointOfInstantiation, InstantiationRange, Entity,
753 nullptr, TemplateArgs) {}
761 PointOfInstantiation, InstantiationRange, Param, Template,
770 PointOfInstantiation, InstantiationRange, nullptr,
771 nullptr,
std::nullopt, &DeductionInfo) {
780 PointOfInstantiation, InstantiationRange, nullptr,
781 nullptr,
std::nullopt) {}
788 PointOfInstantiation, InstantiationRange, nullptr,
789 nullptr,
std::nullopt, &DeductionInfo) {
798 PointOfInstantiation, InstantiationRange, Template, nullptr,
807 PointOfInstantiation, InstantiationRange, Template, nullptr,
808 {}, &DeductionInfo) {}
816 PointOfInstantiation, InstantiationRange, Template) {}
824 PointOfInstantiation, InstantiationRange, Template) {}
831 PointOfInstantiation, InstantiationRange, Entity) {}
851 if (!Active.isInstantiationRecord()) {
861 "forgot to remove a lookup module for a template instantiation");
880 if (!AlreadyInstantiating) {
884 {Active.Entity->getCanonicalDecl(), Active.Kind});
898 llvm::raw_string_ostream
OS(
Result);
899 llvm::ListSeparator Comma;
900 for (
const Expr *Arg : Args) {
902 Arg->IgnoreParens()->printPretty(
OS,
nullptr,
908bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
919 diag::err_template_recursion_depth_exceeded)
921 << InstantiationRange;
922 SemaRef.
Diag(PointOfInstantiation, diag::note_template_recursion_depth)
934 SkipStart = Limit / 2 + Limit % 2;
939 unsigned InstantiationIdx = 0;
944 ++Active, ++InstantiationIdx) {
946 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
947 if (InstantiationIdx == SkipStart) {
950 diag::note_instantiation_contexts_suppressed)
956 switch (Active->Kind) {
958 Decl *D = Active->Entity;
960 unsigned DiagID = diag::note_template_member_class_here;
961 if (isa<ClassTemplateSpecializationDecl>(
Record))
962 DiagID = diag::note_template_class_instantiation_here;
964 <<
Record << Active->InstantiationRange;
968 DiagID = diag::note_function_template_spec_here;
970 DiagID = diag::note_template_member_function_here;
973 << Active->InstantiationRange;
974 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
976 VD->isStaticDataMember()?
977 diag::note_template_static_data_member_def_here
978 : diag::note_template_variable_def_here)
980 << Active->InstantiationRange;
981 }
else if (
EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
983 diag::note_template_enum_def_here)
985 << Active->InstantiationRange;
986 }
else if (
FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
988 diag::note_template_nsdmi_here)
989 << FD << Active->InstantiationRange;
992 diag::note_template_class_instantiation_here)
993 << CTD << Active->InstantiationRange;
999 TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
1001 llvm::raw_svector_ostream
OS(TemplateArgsStr);
1006 diag::note_default_arg_instantiation_here)
1008 << Active->InstantiationRange;
1015 diag::note_explicit_template_arg_substitution_here)
1018 Active->TemplateArgs,
1019 Active->NumTemplateArgs)
1020 << Active->InstantiationRange;
1026 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
1028 diag::note_function_template_deduction_instantiation_here)
1031 Active->TemplateArgs,
1032 Active->NumTemplateArgs)
1033 << Active->InstantiationRange;
1035 bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
1036 isa<VarTemplateSpecializationDecl>(Active->Entity);
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");
1053 diag::note_deduced_template_arg_substitution_here)
1054 << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
1056 Active->NumTemplateArgs)
1057 << Active->InstantiationRange;
1063 ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
1067 llvm::raw_svector_ostream
OS(TemplateArgsStr);
1072 diag::note_default_function_arg_instantiation_here)
1074 << Active->InstantiationRange;
1079 NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
1082 Name = std::string(
" '") + Parm->
getName().str() +
"'";
1085 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
1086 TemplateParams = Template->getTemplateParameters();
1089 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
1090 ->getTemplateParameters();
1092 diag::note_prior_template_arg_substitution)
1093 << isa<TemplateTemplateParmDecl>(Parm)
1096 Active->TemplateArgs,
1097 Active->NumTemplateArgs)
1098 << Active->InstantiationRange;
1104 if (
TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
1105 TemplateParams = Template->getTemplateParameters();
1108 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
1109 ->getTemplateParameters();
1112 diag::note_template_default_arg_checking)
1114 Active->TemplateArgs,
1115 Active->NumTemplateArgs)
1116 << Active->InstantiationRange;
1122 diag::note_evaluating_exception_spec_here)
1123 << cast<FunctionDecl>(Active->Entity);
1128 diag::note_template_exception_spec_instantiation_here)
1129 << cast<FunctionDecl>(Active->Entity)
1130 << Active->InstantiationRange;
1135 diag::note_template_requirement_instantiation_here)
1136 << Active->InstantiationRange;
1140 diag::note_template_requirement_params_instantiation_here)
1141 << Active->InstantiationRange;
1146 diag::note_nested_requirement_here)
1147 << Active->InstantiationRange;
1152 diag::note_in_declaration_of_implicit_special_member)
1153 << cast<CXXRecordDecl>(Active->Entity)
1154 << llvm::to_underlying(Active->SpecialMember);
1159 diag::note_in_declaration_of_implicit_equality_comparison);
1165 auto *FD = dyn_cast<FunctionDecl>(Active->Entity);
1169 auto *MD = cast<CXXMethodDecl>(FD);
1171 diag::note_member_synthesized_at)
1172 << MD->isExplicitlyDefaulted()
1178 .getNonReferenceType()
1179 .getUnqualifiedType();
1181 diag::note_comparison_synthesized_at)
1189 diag::note_rewriting_operator_as_spaceship);
1194 diag::note_in_binding_decl_init)
1195 << cast<BindingDecl>(Active->Entity);
1200 diag::note_due_to_dllexported_class)
1201 << cast<CXXRecordDecl>(Active->Entity) << !
getLangOpts().CPlusPlus11;
1206 diag::note_building_builtin_dump_struct_call)
1216 diag::note_lambda_substitution_here);
1219 unsigned DiagID = 0;
1220 if (!Active->Entity) {
1222 diag::note_nested_requirement_here)
1223 << Active->InstantiationRange;
1226 if (isa<ConceptDecl>(Active->Entity))
1227 DiagID = diag::note_concept_specialization_here;
1228 else if (isa<TemplateDecl>(Active->Entity))
1229 DiagID = diag::note_checking_constraints_for_template_id_here;
1230 else if (isa<VarTemplatePartialSpecializationDecl>(Active->Entity))
1231 DiagID = diag::note_checking_constraints_for_var_spec_id_here;
1232 else if (isa<ClassTemplatePartialSpecializationDecl>(Active->Entity))
1233 DiagID = diag::note_checking_constraints_for_class_spec_id_here;
1235 assert(isa<FunctionDecl>(Active->Entity));
1236 DiagID = diag::note_checking_constraints_for_function_here;
1239 llvm::raw_svector_ostream
OS(TemplateArgsStr);
1241 if (!isa<FunctionDecl>(Active->Entity)) {
1245 Diags.
Report(Active->PointOfInstantiation, DiagID) <<
OS.str()
1246 << Active->InstantiationRange;
1251 diag::note_constraint_substitution_here)
1252 << Active->InstantiationRange;
1256 diag::note_constraint_normalization_here)
1257 << cast<NamedDecl>(Active->Entity)->getName()
1258 << Active->InstantiationRange;
1262 diag::note_parameter_mapping_substitution_here)
1263 << Active->InstantiationRange;
1267 diag::note_building_deduction_guide_here);
1271 diag::note_template_type_alias_instantiation_here)
1272 << cast<TypeAliasTemplateDecl>(Active->Entity)
1273 << Active->InstantiationRange;
1281 return std::optional<TemplateDeductionInfo *>(
nullptr);
1286 Active != ActiveEnd;
1289 switch (Active->Kind) {
1293 if (isa<TypeAliasTemplateDecl>(Active->Entity))
1304 return std::nullopt;
1311 return std::nullopt;
1332 assert(Active->DeductionInfo &&
"Missing deduction info pointer");
1333 return Active->DeductionInfo;
1344 return std::nullopt;
1358 if (Active->SavedInNonInstantiationSFINAEContext)
1359 return std::optional<TemplateDeductionInfo *>(
nullptr);
1362 return std::nullopt;
1369 class TemplateInstantiator :
public TreeTransform<TemplateInstantiator> {
1374 bool EvaluateConstraints =
true;
1379 TemplateInstantiator(
Sema &SemaRef,
1382 : inherited(SemaRef), TemplateArgs(TemplateArgs),
Loc(
Loc),
1385 void setEvaluateConstraints(
bool B) {
1386 EvaluateConstraints = B;
1388 bool getEvaluateConstraints() {
1389 return EvaluateConstraints;
1409 this->Entity = Entity;
1412 unsigned TransformTemplateDepth(
unsigned Depth) {
1417 int Index = getSema().ArgumentPackSubstitutionIndex;
1419 return std::nullopt;
1426 bool &ShouldExpand,
bool &RetainExpansion,
1427 std::optional<unsigned> &NumExpansions) {
1428 return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
1429 PatternRange, Unexpanded,
1436 void ExpandingFunctionParameterPack(
ParmVarDecl *Pack) {
1446 unsigned Depth, Index;
1449 Result = TemplateArgs(Depth, Index);
1465 unsigned Depth, Index;
1475 void transformAttrs(
Decl *Old,
Decl *New) {
1482 for (
auto *New : NewDecls)
1484 Old, cast<VarDecl>(New));
1488 assert(NewDecls.size() == 1 &&
1489 "should only have multiple expansions for a pack");
1490 Decl *New = NewDecls.front();
1495 auto *NewMD = dyn_cast<CXXMethodDecl>(New);
1497 auto *OldMD = dyn_cast<CXXMethodDecl>(Old);
1498 if (
auto *NewTD = NewMD->getDescribedFunctionTemplate())
1499 NewTD->setInstantiatedFromMemberTemplate(
1500 OldMD->getDescribedFunctionTemplate());
1502 NewMD->setInstantiationOfMemberFunction(OldMD,
1510 if (
auto *DC = dyn_cast<DeclContext>(Old);
1511 DC && DC->isDependentContext() && DC->isFunctionOrMethod())
1552 NamedDecl *FirstQualifierInScope =
nullptr,
1553 bool AllowInjectedClassName =
false);
1555 const CXXAssumeAttr *TransformCXXAssumeAttr(
const CXXAssumeAttr *AA);
1556 const LoopHintAttr *TransformLoopHintAttr(
const LoopHintAttr *LH);
1557 const NoInlineAttr *TransformStmtNoInlineAttr(
const Stmt *OrigS,
1559 const NoInlineAttr *A);
1560 const AlwaysInlineAttr *
1561 TransformStmtAlwaysInlineAttr(
const Stmt *OrigS,
const Stmt *InstS,
1562 const AlwaysInlineAttr *A);
1563 const CodeAlignAttr *TransformCodeAlignAttr(
const CodeAlignAttr *CA);
1570 ExprResult TransformSubstNonTypeTemplateParmPackExpr(
1572 ExprResult TransformSubstNonTypeTemplateParmExpr(
1589 return inherited::TransformFunctionProtoType(TLB, TL);
1594 auto Type = inherited::TransformInjectedClassNameType(TLB, TL);
1597 if (
Type.isNull() &&
1604 inherited::TransformType(ICT->getInjectedSpecializationType());
1615 bool Uneval =
false) {
1617 std::vector<TemplateArgument> TArgs;
1625 "Transforming a template argument pack is only allowed in building "
1642 return inherited::TransformTemplateArgument(Input, Output, Uneval);
1645 template<
typename Fn>
1650 Fn TransformExceptionSpec);
1653 TransformFunctionTypeParam(
ParmVarDecl *OldParm,
int indexAdjustment,
1654 std::optional<unsigned> NumExpansions,
1655 bool ExpectParameterPack);
1657 using inherited::TransformTemplateTypeParmType;
1662 bool SuppressObjCLifetime);
1664 QualType BuildSubstTemplateTypeParmType(
1666 Decl *AssociatedDecl,
unsigned Index, std::optional<unsigned> PackIndex,
1672 using inherited::TransformSubstTemplateTypeParmPackType;
1676 bool SuppressObjCLifetime);
1683 unsigned TypeAliasDeclDepth = CCS.Entity->getTemplateDepth();
1685 return CXXRecordDecl::LambdaDependencyKind::LDK_AlwaysDependent;
1687 return inherited::ComputeLambdaDependency(LSI);
1694 ExprResult Result = inherited::TransformLambdaExpr(E);
1695 if (Result.isInvalid())
1700 assert(PVD &&
"null in a parameter list");
1701 if (!PVD->hasDefaultArg())
1703 Expr *UninstExpr = PVD->getUninstantiatedDefaultArg();
1712 { UninstExpr }, UninstExpr->
getType());
1714 PVD->setDefaultArg(ErrorResult.
get());
1731 bool Prev = EvaluateConstraints;
1732 EvaluateConstraints =
true;
1734 EvaluateConstraints = Prev;
1740 ExprResult TransReq = inherited::TransformRequiresExpr(E);
1743 assert(TransReq.
get() != E &&
1744 "Do not change value of isSatisfied for the existing expression. "
1745 "Create a new expression instead.");
1752 if (Trap.hasErrorOccurred())
1758 bool TransformRequiresExprRequirements(
1761 bool SatisfactionDetermined =
false;
1764 if (!SatisfactionDetermined) {
1765 if (
auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req))
1766 TransReq = TransformTypeRequirement(TypeReq);
1767 else if (
auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req))
1768 TransReq = TransformExprRequirement(ExprReq);
1770 TransReq = TransformNestedRequirement(
1771 cast<concepts::NestedRequirement>(Req));
1780 SatisfactionDetermined =
true;
1783 Transformed.push_back(TransReq);
1790 if (!OrigTPL || !OrigTPL->
size())
return OrigTPL;
1794 Owner, TemplateArgs);
1795 DeclInstantiator.setEvaluateConstraints(EvaluateConstraints);
1796 return DeclInstantiator.SubstTemplateParams(OrigTPL);
1814 transformNonTypeTemplateParmRef(
Decl *AssociatedDecl,
1817 std::optional<unsigned> PackIndex);
1821bool TemplateInstantiator::AlreadyTransformed(
QualType T) {
1828 getSema().MarkDeclarationsReferencedInType(
Loc,
T);
1853 TTP->getPosition()))
1858 if (TTP->isParameterPack()) {
1860 "Missing argument pack");
1866 "Wrong kind of template template argument");
1878 Decl *Inst = getSema().SubstDecl(D, getSema().
CurContext, TemplateArgs);
1882 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1886bool TemplateInstantiator::TransformExceptionSpec(
1893 return inherited::TransformExceptionSpec(
Loc, ESI, Exceptions, Changed);
1897TemplateInstantiator::TransformFirstQualifierInScope(
NamedDecl *D,
1911 "Missing argument pack");
1921 return cast_or_null<NamedDecl>(TransformDecl(
Loc, D));
1924 return Tag->getDecl();
1927 getSema().Diag(
Loc, diag::err_nested_name_spec_non_tag) <<
T;
1932 return cast_or_null<NamedDecl>(TransformDecl(
Loc, D));
1936TemplateInstantiator::RebuildExceptionDecl(
VarDecl *ExceptionDecl,
1942 StartLoc, NameLoc, Name);
1944 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1948VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(
VarDecl *ExceptionDecl,
1951 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo,
T);
1953 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1958TemplateInstantiator::RebuildElaboratedType(
SourceLocation KeywordLoc,
1976 SemaRef.
Diag(TagLocation, diag::err_use_with_wrong_tag)
1985 return inherited::RebuildElaboratedType(KeywordLoc, Keyword, QualifierLoc,
T);
1988TemplateName TemplateInstantiator::TransformTemplateName(
1991 bool AllowInjectedClassName) {
1993 = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {
2000 TTP->getPosition()))
2010 "unexpected pack arguments in template rewrite");
2014 "unexpected nontype template argument kind in template rewrite");
2018 auto [AssociatedDecl, Final] =
2020 std::optional<unsigned> PackIndex;
2023 "Missing argument pack");
2029 return getSema().Context.getSubstTemplateTemplateParmPack(
2030 Arg, AssociatedDecl, TTP->
getIndex(), Final);
2033 PackIndex = getPackIndex(Arg);
2038 assert(!Template.
isNull() &&
"Null template template argument");
2040 "template decl to substitute is qualified?");
2044 return getSema().Context.getSubstTemplateTemplateParm(
2045 Template, AssociatedDecl, TTP->
getIndex(), PackIndex);
2050 = Name.getAsSubstTemplateTemplateParmPack()) {
2057 if (SubstPack->getFinal())
2059 return getSema().Context.getSubstTemplateTemplateParm(
2061 SubstPack->getIndex(), getPackIndex(Pack));
2064 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
2065 FirstQualifierInScope,
2066 AllowInjectedClassName);
2070TemplateInstantiator::TransformPredefinedExpr(
PredefinedExpr *E) {
2078TemplateInstantiator::TransformTemplateParmRefExpr(
DeclRefExpr *E,
2095 "unexpected pack arguments in template rewrite");
2099 "unexpected nontype template argument kind in template rewrite");
2106 std::optional<unsigned> PackIndex;
2109 "Missing argument pack");
2129 PackIndex = getPackIndex(Arg);
2133 return transformNonTypeTemplateParmRef(AssociatedDecl, NTTP, E->
getLocation(),
2137const CXXAssumeAttr *
2138TemplateInstantiator::TransformCXXAssumeAttr(
const CXXAssumeAttr *AA) {
2139 ExprResult Res = getDerived().TransformExpr(AA->getAssumption());
2143 Res = getSema().BuildCXXAssumeExpr(Res.
get(), AA->getAttrName(),
2148 return CXXAssumeAttr::CreateImplicit(getSema().
Context, Res.
get(),
2153TemplateInstantiator::TransformLoopHintAttr(
const LoopHintAttr *LH) {
2154 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).get();
2156 if (TransformedExpr == LH->getValue())
2161 LH->getSemanticSpelling() ==
2162 LoopHintAttr::Pragma_unroll))
2165 LoopHintAttr::OptionType Option = LH->getOption();
2166 LoopHintAttr::LoopHintState State = LH->getState();
2168 llvm::APSInt ValueAPS =
2171 if (ValueAPS.isZero() || ValueAPS.isOne()) {
2172 Option = LoopHintAttr::Unroll;
2173 State = LoopHintAttr::Disable;
2178 return LoopHintAttr::CreateImplicit(getSema().
Context, Option, State,
2179 TransformedExpr, *LH);
2181const NoInlineAttr *TemplateInstantiator::TransformStmtNoInlineAttr(
2182 const Stmt *OrigS,
const Stmt *InstS,
const NoInlineAttr *A) {
2188const AlwaysInlineAttr *TemplateInstantiator::TransformStmtAlwaysInlineAttr(
2189 const Stmt *OrigS,
const Stmt *InstS,
const AlwaysInlineAttr *A) {
2196const CodeAlignAttr *
2197TemplateInstantiator::TransformCodeAlignAttr(
const CodeAlignAttr *CA) {
2198 Expr *TransformedExpr = getDerived().TransformExpr(CA->getAlignment()).get();
2199 return getSema().BuildCodeAlignAttr(*CA, TransformedExpr);
2202ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
2205 std::optional<unsigned> PackIndex) {
2210 auto SubstParamType = [&] {
2217 T = cast<PackExpansionType>(
T)->getPattern();
2221 bool refParam =
false;
2227 Expr *argExpr =
arg.getAsExpr();
2232 QualType paramType = SubstParamType();
2247 VD = cast_or_null<ValueDecl>(
2253 QualType paramType =
arg.getNonTypeTemplateArgumentType();
2254 assert(!paramType.
isNull() &&
"type substitution failed for param type");
2255 assert(!paramType->
isDependentType() &&
"param type still dependent");
2259 QualType paramType =
arg.getNonTypeTemplateArgumentType();
2270 Expr *resultExpr = result.
get();
2274 AssociatedDecl, parm->
getIndex(), PackIndex, refParam);
2278TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
2288 return transformNonTypeTemplateParmRef(
2294TemplateInstantiator::TransformSubstNonTypeTemplateParmExpr(
2297 if (!isa<ConstantExpr>(SubstReplacement.
get()))
2327 SubstReplacement.
get(), SugaredConverted,
2339 return getSema().BuildDeclarationNameExpr(
CXXScopeSpec(), NameInfo, PD);
2350 return RebuildVarDeclRefExpr(VD, E->
getExprLoc());
2372 getSema().MarkFunctionParmPackReferenced(PackExpr);
2377TemplateInstantiator::TransformFunctionParmPackRefExpr(
DeclRefExpr *E,
2380 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
2381 = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
2382 assert(Found &&
"no instantiation for parameter pack");
2384 Decl *TransformedDecl;
2385 if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
2394 getSema().MarkFunctionParmPackReferenced(PackExpr);
2398 TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
2400 TransformedDecl = Found->get<
Decl*>();
2404 return RebuildVarDeclRefExpr(cast<VarDecl>(TransformedDecl), E->
getExprLoc());
2408TemplateInstantiator::TransformDeclRefExpr(
DeclRefExpr *E) {
2415 return TransformTemplateParmRefExpr(E, NTTP);
2422 if (
VarDecl *PD = dyn_cast<VarDecl>(D))
2424 return TransformFunctionParmPackRefExpr(E, PD);
2426 return inherited::TransformDeclRefExpr(E);
2429ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
2432 getDescribedFunctionTemplate() &&
2433 "Default arg expressions are never formed in dependent cases.");
2439template<
typename Fn>
2444 Fn TransformExceptionSpec) {
2447 return inherited::TransformFunctionProtoType(
2448 TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
2451ParmVarDecl *TemplateInstantiator::TransformFunctionTypeParam(
2453 std::optional<unsigned> NumExpansions,
bool ExpectParameterPack) {
2455 OldParm, TemplateArgs, indexAdjustment, NumExpansions,
2456 ExpectParameterPack, EvaluateConstraints);
2462QualType TemplateInstantiator::BuildSubstTemplateTypeParmType(
2464 Decl *AssociatedDecl,
unsigned Index, std::optional<unsigned> PackIndex,
2470 if (SuppressObjCLifetime) {
2472 RQs = Replacement.getQualifiers();
2483 QualType Result = getSema().Context.getSubstTemplateTypeParmType(
2484 Replacement, AssociatedDecl, Index, PackIndex);
2492TemplateInstantiator::TransformTemplateTypeParmType(
TypeLocBuilder &TLB,
2494 bool SuppressObjCLifetime) {
2518 "unexpected pack arguments in template rewrite");
2522 "unexpected nontype template argument kind in template rewrite");
2528 auto [AssociatedDecl, Final] =
2530 std::optional<unsigned> PackIndex;
2531 if (
T->isParameterPack()) {
2533 "Missing argument pack");
2539 QualType Result = getSema().Context.getSubstTemplateTypeParmPackType(
2540 AssociatedDecl,
T->getIndex(), Final, Arg);
2548 PackIndex = getPackIndex(Arg);
2553 "Template argument kind mismatch");
2555 return BuildSubstTemplateTypeParmType(TLB, SuppressObjCLifetime, Final,
2556 AssociatedDecl,
T->getIndex(),
2566 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
2570 T->isParameterPack(), NewTTPDecl);
2576QualType TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
2578 bool SuppressObjCLifetime) {
2581 Decl *NewReplaced = TransformDecl(TL.
getNameLoc(),
T->getAssociatedDecl());
2586 if (NewReplaced !=
T->getAssociatedDecl())
2587 Result = getSema().Context.getSubstTemplateTypeParmPackType(
2588 NewReplaced,
T->getIndex(),
T->getFinal(),
T->getArgumentPack());
2597 return BuildSubstTemplateTypeParmType(
2598 TLB, SuppressObjCLifetime,
T->getFinal(), NewReplaced,
T->getIndex(),
2612 ErrorLoc = PDA.first;
2616 char *MessageBuf =
new (S.
Context)
char[Message.size()];
2617 std::copy(Message.begin(), Message.end(), MessageBuf);
2619 llvm::raw_svector_ostream
OS(Entity);
2621 char *EntityBuf =
new (S.
Context)
char[Entity.size()];
2622 std::copy(Entity.begin(), Entity.end(), EntityBuf);
2624 StringRef(EntityBuf, Entity.size()), ErrorLoc,
2625 StringRef(MessageBuf, Message.size())};
2632 llvm::raw_svector_ostream
OS(Entity);
2634 char *EntityBuf =
new (S.
Context)
char[Entity.size()];
2635 llvm::copy(Entity, EntityBuf);
2637 StringRef(EntityBuf, Entity.size()),
2638 Location, StringRef()};
2641ExprResult TemplateInstantiator::TransformRequiresTypeParams(
2655 if (getDerived().TransformFunctionTypeParams(
2656 KWLoc, Params,
nullptr,
nullptr, PTypes,
2657 &TransParams, PInfos, &ErrorIdx) ||
2658 Trap.hasErrorOccurred()) {
2664 SemaRef, Info, [&](llvm::raw_ostream &
OS) {
OS << *FailedDecl; })));
2665 return getDerived().RebuildRequiresExpr(KWLoc, Body, RE->
getLParenLoc(),
2667 TransReqs, RBraceLoc);
2678 if (AlwaysRebuild())
2679 return RebuildTypeRequirement(
2689 if (TypeInst.isInvalid())
2692 if (!TransType || Trap.hasErrorOccurred())
2694 [&] (llvm::raw_ostream&
OS) {
2697 return RebuildTypeRequirement(TransType);
2707 llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *>
2716 if (ExprInst.isInvalid())
2719 if (!TransExprRes.
isInvalid() && !Trap.hasErrorOccurred() &&
2722 if (TransExprRes.
isInvalid() || Trap.hasErrorOccurred())
2727 TransExpr = TransExprRes.
get();
2730 std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;
2732 if (RetReq.isEmpty())
2733 TransRetReq.emplace();
2734 else if (RetReq.isSubstitutionFailure())
2735 TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
2736 else if (RetReq.isTypeConstraint()) {
2738 RetReq.getTypeConstraintTemplateParameterList();
2742 if (TPLInst.isInvalid())
2747 [&] (llvm::raw_ostream&
OS) {
2748 RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()
2753 TransRetReq.emplace(TPL);
2756 assert(TransRetReq &&
"All code paths leading here must set TransRetReq");
2757 if (
Expr *E = TransExpr.dyn_cast<
Expr *>())
2759 std::move(*TransRetReq));
2760 return RebuildExprRequirement(
2766TemplateInstantiator::TransformNestedRequirement(
2771 if (AlwaysRebuild())
2780 if (!getEvaluateConstraints()) {
2782 if (TransConstraint.
isInvalid() || !TransConstraint.
get())
2802 if (ConstrInst.isInvalid())
2806 nullptr, {Req->getConstraintExpr()},
Result, TemplateArgs,
2809 TransConstraint =
Result[0];
2810 assert(!Trap.hasErrorOccurred() &&
"Substitution failures must be handled "
2811 "by CheckConstraintSatisfaction.");
2817 if (TransConstraint.
isInvalid() || !TransConstraint.
get() ||
2820 llvm::raw_svector_ostream
OS(Entity);
2824 std::copy(Entity.begin(), Entity.end(), EntityBuf);
2826 SemaRef.
Context, StringRef(EntityBuf, Entity.size()), Satisfaction);
2867 bool AllowDeducedTST) {
2869 "Cannot perform an instantiation without some context on the "
2870 "instantiation stack");
2876 TemplateInstantiator Instantiator(*
this, Args,
Loc, Entity);
2877 return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(
T)
2878 : Instantiator.TransformType(
T);
2886 "Cannot perform an instantiation without some context on the "
2887 "instantiation stack");
2901 TemplateInstantiator Instantiator(*
this, Args,
Loc, Entity);
2916 "Cannot perform an instantiation without some context on the "
2917 "instantiation stack");
2924 TemplateInstantiator Instantiator(*
this, TemplateArgs,
Loc, Entity);
2925 return Instantiator.TransformType(
T);
2933 TypeLoc TL =
T->getTypeLoc().IgnoreParens();
2960 bool EvaluateConstraints) {
2962 "Cannot perform an instantiation without some context on the "
2963 "instantiation stack");
2968 TemplateInstantiator Instantiator(*
this, Args,
Loc, Entity);
2969 Instantiator.setEvaluateConstraints(EvaluateConstraints);
2985 Result = Instantiator.TransformFunctionProtoType(
2986 TLB, Proto, ThisContext, ThisTypeQuals,
2988 bool &Changed) {
return false; });
2990 Result = Instantiator.TransformType(TLB, TL);
3004 bool Changed =
false;
3006 return Instantiator.TransformExceptionSpec(
Loc, ESI, ExceptionStorage,
3017 ESI, ExceptionStorage, Args))
3026 struct GetContainedInventedTypeParmVisitor :
3027 public TypeVisitor<GetContainedInventedTypeParmVisitor,
3028 TemplateTypeParmDecl *> {
3029 using TypeVisitor<GetContainedInventedTypeParmVisitor,
3035 return Visit(
T.getTypePtr());
3040 if (!
T->getDecl() || !
T->getDecl()->isImplicit())
3042 return T->getDecl();
3049 return Visit(
T->getNamedType());
3061 return Visit(
T->getPointeeTypeAsWritten());
3069 return Visit(
T->getElementType());
3074 return Visit(
T->getElementType());
3078 return Visit(
T->getElementType());
3082 return VisitFunctionType(
T);
3090 return Visit(
T->getInnerType());
3094 return Visit(
T->getModifiedType());
3098 return Visit(
T->getUnderlyingType());
3102 return Visit(
T->getOriginalType());
3106 return Visit(
T->getPattern());
3115 bool EvaluateConstraints) {
3119 if (!EvaluateConstraints) {
3146 int indexAdjustment, std::optional<unsigned> NumExpansions,
3147 bool ExpectParameterPack,
bool EvaluateConstraint) {
3156 NewDI =
SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
3167 }
else if (ExpectParameterPack) {
3173 diag::err_function_parameter_pack_without_parameter_packs)
3197 GetContainedInventedTypeParmVisitor().Visit(OldDI->
getType())) {
3199 auto *Inst = cast_or_null<TemplateTypeParmDecl>(
3204 if (Inst && !Inst->getTypeConstraint()) {
3276 "Cannot perform an instantiation without some context on the "
3277 "instantiation stack");
3279 TemplateInstantiator Instantiator(*
this, TemplateArgs,
Loc,
3281 return Instantiator.TransformFunctionTypeParams(
3282 Loc, Params,
nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
3301 Diag(Param->
getBeginLoc(), diag::err_recursive_default_argument) << FD;
3313 std::unique_ptr<LocalInstantiationScope> LIS;
3322 LIS = std::make_unique<LocalInstantiationScope>(*
this);
3325 if (addInstantiatedParametersToScope(FD, PatternFD, *LIS, TemplateArgs))
3328 if (PrimaryTemplate && PrimaryTemplate->
isOutOfLine()) {
3334 CurrentTemplateArgumentList->
asArray(),
true);
3356 Result = InitSeq.Perform(*
this, Entity, Kind, ResultE);
3389 for (
const auto &
Base : Pattern->
bases()) {
3390 if (!
Base.getType()->isDependentType()) {
3392 if (RD->isInvalidDecl())
3401 if (
Base.isPackExpansion()) {
3407 bool ShouldExpand =
false;
3408 bool RetainExpansion =
false;
3409 std::optional<unsigned> NumExpansions;
3411 Base.getSourceRange(),
3413 TemplateArgs, ShouldExpand,
3422 for (
unsigned I = 0; I != *NumExpansions; ++I) {
3427 Base.getSourceRange().getBegin(),
3436 Base.getSourceRange(),
3438 Base.getAccessSpecifierAsWritten(),
3441 InstantiatedBases.push_back(InstantiatedBase);
3450 EllipsisLoc =
Base.getEllipsisLoc();
3454 Base.getSourceRange().getBegin(),
3459 Base.getSourceRange().getBegin(),
3470 Base.getSourceRange(),
3472 Base.getAccessSpecifierAsWritten(),
3475 InstantiatedBases.push_back(InstantiatedBase);
3529 Pattern, PatternDef, TSK, Complain))
3532 llvm::TimeTraceScope TimeScope(
"InstantiateClass", [&]() {
3534 llvm::raw_string_ostream
OS(Name);
3540 Pattern = PatternDef;
3546 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3548 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
3549 Spec->setTemplateSpecializationKind(TSK);
3550 Spec->setPointOfInstantiation(PointOfInstantiation);
3558 "instantiating class definition");
3576 SavePendingParsedClassStateRAII SavedPendingParsedClassState(*
this);
3602 bool MightHaveConstexprVirtualFunctions =
false;
3613 if (
Member->getDeclContext() != Pattern)
3620 if (isa<BlockDecl>(
Member) ||
3621 (isa<CXXRecordDecl>(
Member) && cast<CXXRecordDecl>(
Member)->isLambda()))
3624 if (
Member->isInvalidDecl()) {
3631 if (
FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
3632 Fields.push_back(Field);
3633 }
else if (
EnumDecl *
Enum = dyn_cast<EnumDecl>(NewMember)) {
3639 Enum->isCompleteDefinition()) {
3641 assert(MSInfo &&
"no spec info for member enum specialization");
3646 if (SA->isFailed()) {
3652 }
else if (
CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewMember)) {
3655 MightHaveConstexprVirtualFunctions =
true;
3676 if (ParsingClassDepth == 0)
3681 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
3682 E = LateAttrs.end(); I != E; ++I) {
3687 auto *ND = cast<NamedDecl>(I->NewDecl);
3688 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
3690 ND->isCXXInstanceMember());
3695 I->NewDecl->addAttr(NewAttr);
3724 P->first,
P->second)) {
3737 P->first,
P->second)) {
3754 else if (MightHaveConstexprVirtualFunctions)
3786 Pattern, PatternDef, TSK,
true))
3788 Pattern = PatternDef;
3794 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3803 "instantiating enum definition");
3853 "pattern and instantiation disagree about init style");
3861 Diag(PointOfInstantiation,
3862 diag::err_default_member_initializer_not_yet_parsed)
3863 << OutermostClass << Pattern;
3864 Diag(Pattern->getEndLoc(),
3865 diag::note_default_member_initializer_not_yet_parsed);
3875 Diag(PointOfInstantiation, diag::err_default_member_initializer_cycle)
3880 "instantiating default member init");
3888 PointOfInstantiation, Instantiation,
CurContext};
3899 assert((!
Init || !isa<ParenListExpr>(
Init)) &&
"call-style init in class");
3904 L->DefaultMemberInitializerInstantiated(Instantiation);
3913 struct PartialSpecMatchResult {
3928 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
3973 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
3986 Matched.push_back(PartialSpecMatchResult());
3987 Matched.back().Partial = Partial;
3996 if (Matched.size() >= 1) {
3998 if (Matched.size() == 1) {
4011 PEnd = Matched.end();
4014 P->Partial, Best->Partial, PointOfInstantiation) ==
4021 bool Ambiguous =
false;
4023 PEnd = Matched.end();
4026 P->Partial, Best->Partial,
4027 PointOfInstantiation) != Best->Partial) {
4037 S.
Diag(PointOfInstantiation,
4038 diag::err_partial_spec_ordering_ambiguous)
4039 << ClassTemplateSpec;
4043 PEnd = Matched.end();
4045 S.
Diag(
P->Partial->getLocation(), diag::note_partial_spec_match)
4047 P->Partial->getTemplateParameters(), *
P->Args);
4062 if (
auto *PartialSpec =
4065 while (PartialSpec->getInstantiatedFromMember()) {
4068 if (PartialSpec->isMemberSpecialization())
4071 PartialSpec = PartialSpec->getInstantiatedFromMember();
4073 Pattern = PartialSpec;
4095 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
4102 ClassTemplateSpec, TSK);
4107 PointOfInstantiation, ClassTemplateSpec, Pattern.
get(),
4126 "Unexpected template specialization kind!");
4127 for (
auto *D : Instantiation->
decls()) {
4128 bool SuppressNew =
false;
4129 if (
auto *
Function = dyn_cast<FunctionDecl>(D)) {
4131 Function->getInstantiatedFromMemberFunction()) {
4133 if (
Function->isIneligibleOrNotSelected())
4136 if (
Function->getTrailingRequiresClause()) {
4144 if (
Function->hasAttr<ExcludeFromExplicitInstantiationAttr>())
4148 Function->getMemberSpecializationInfo();
4149 assert(MSInfo &&
"No member specialization information?");
4171 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
4181 std::make_pair(
Function, PointOfInstantiation));
4184 }
else if (
auto *Var = dyn_cast<VarDecl>(D)) {
4185 if (isa<VarTemplateSpecializationDecl>(Var))
4189 if (Var->
hasAttr<ExcludeFromExplicitInstantiationAttr>())
4193 assert(MSInfo &&
"No member specialization information?");
4222 }
else if (
auto *
Record = dyn_cast<CXXRecordDecl>(D)) {
4223 if (
Record->hasAttr<ExcludeFromExplicitInstantiationAttr>())
4231 if (
Record->isInjectedClassName() ||
Record->getPreviousDecl() ||
4236 assert(MSInfo &&
"No member specialization information?");
4262 assert(Pattern &&
"Missing instantiated-from-template information");
4264 if (!
Record->getDefinition()) {
4285 Record->getTemplateSpecializationKind() ==
4287 Record->setTemplateSpecializationKind(TSK);
4292 Pattern = cast_or_null<CXXRecordDecl>(
Record->getDefinition());
4296 }
else if (
auto *
Enum = dyn_cast<EnumDecl>(D)) {
4298 assert(MSInfo &&
"No member specialization information?");
4305 PointOfInstantiation, TSK,
Enum,
4311 if (
Enum->getDefinition())
4314 EnumDecl *Pattern =
Enum->getTemplateInstantiationPattern();
4315 assert(Pattern &&
"Missing instantiated-from-template information");
4326 }
else if (
auto *Field = dyn_cast<FieldDecl>(D)) {
4333 ClassPattern->
lookup(Field->getDeclName());
4369 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4372 return Instantiator.TransformStmt(S);
4379 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4381 return Instantiator.TransformTemplateArgument(Input, Output);
4388 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4390 return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(), Out);
4398 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4401 return Instantiator.TransformExpr(E);
4417 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4419 Instantiator.setEvaluateConstraints(
false);
4420 return Instantiator.TransformExpr(E);
4425 bool CXXDirectInit) {
4426 TemplateInstantiator Instantiator(*
this, TemplateArgs,
SourceLocation(),
4428 return Instantiator.TransformInitializer(
Init, CXXDirectInit);
4437 TemplateInstantiator Instantiator(*
this, TemplateArgs,
4440 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
4450 TemplateInstantiator Instantiator(*
this, TemplateArgs, NNS.
getBeginLoc(),
4452 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
4459 TemplateInstantiator Instantiator(*
this, TemplateArgs, NameInfo.
getLoc(),
4461 return Instantiator.TransformDeclarationNameInfo(NameInfo);
4468 TemplateInstantiator Instantiator(*
this, TemplateArgs,
Loc,
4471 SS.
Adopt(QualifierLoc);
4472 return Instantiator.TransformTemplateName(SS, Name,
Loc);
4480 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
4481 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
4482 unsigned i = PV->getFunctionScopeIndex();
4485 if (i < FD->getNumParams() && FD->getParamDecl(i) == PV)
4493llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
4497 Current = Current->Outer) {
4500 const Decl *CheckD = D;
4502 LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
4503 if (Found != Current->LocalDecls.end())
4504 return &Found->second;
4508 if (
const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
4515 if (!Current->CombineWithOuterScope)
4521 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
4522 isa<TemplateTemplateParmDecl>(D))
4527 if (RD->isLocalClass())
4532 if (isa<EnumDecl>(D))
4537 if (isa<TypedefNameDecl>(D) &&
4544 assert(isa<LabelDecl>(D) &&
"declaration not instantiated in this scope");
4550 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
4551 if (Stored.isNull()) {
4555 while (Current->CombineWithOuterScope && Current->Outer) {
4556 Current = Current->Outer;
4557 assert(!Current->LocalDecls.contains(D) &&
4558 "Instantiated local in inner and outer scopes");
4563 Pack->push_back(cast<VarDecl>(Inst));
4565 assert(Stored.get<
Decl *>() == Inst &&
"Already instantiated this local");
4573 Pack->push_back(Inst);
4580 Current && Current->CombineWithOuterScope; Current = Current->Outer)
4581 assert(!Current->LocalDecls.contains(D) &&
4582 "Creating local pack after instantiation of local");
4586 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
4589 ArgumentPacks.push_back(Pack);
4594 if (llvm::is_contained(*Pack, D))
4601 unsigned NumExplicitArgs) {
4602 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&
4603 "Already have a partially-substituted pack");
4604 assert((!PartiallySubstitutedPack
4605 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&
4606 "Wrong number of arguments in partially-substituted pack");
4607 PartiallySubstitutedPack = Pack;
4608 ArgsInPartiallySubstitutedPack = ExplicitArgs;
4609 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
4614 unsigned *NumExplicitArgs)
const {
4616 *ExplicitArgs =
nullptr;
4617 if (NumExplicitArgs)
4618 *NumExplicitArgs = 0;
4621 Current = Current->Outer) {
4622 if (Current->PartiallySubstitutedPack) {
4624 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
4625 if (NumExplicitArgs)
4626 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
4628 return Current->PartiallySubstitutedPack;
4631 if (!Current->CombineWithOuterScope)
This file provides AST data structures related to concepts.
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines the C++ template declaration subclasses.
Defines Expressions and AST nodes for C++2a concepts.
static void print(llvm::raw_ostream &OS, const T &V, ASTContext &, QualType)
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
MatchFinder::MatchResult MatchResult
static const Decl * getCanonicalParmVarDecl(const Decl *D)
static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T)
static concepts::Requirement::SubstitutionDiagnostic * createSubstDiag(Sema &S, TemplateDeductionInfo &Info, concepts::EntityPrinter Printer)
static ActionResult< CXXRecordDecl * > getPatternForClassTemplateSpecialization(Sema &S, SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK)
Get the instantiation pattern to use to instantiate the definition of a given ClassTemplateSpecializa...
static std::string convertCallArgsToString(Sema &S, llvm::ArrayRef< const Expr * > Args)
static TemplateArgument getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg)
Defines utilities for dealing with stack allocation and stack space.
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
virtual void HandleTagDeclDefinition(TagDecl *D)
HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TranslationUnitDecl * getTranslationUnitDecl() const
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
const clang::PrintingPolicy & getPrintingPolicy() const
const TargetInfo & getTargetInfo() const
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Attr - This represents one attribute.
An attributed type is a type to which a type attribute has been applied.
Represents a base class of a C++ class.
A default argument (C++ [dcl.fct.default]).
SourceLocation getUsedLocation() const
Retrieve the location where this default argument was actually used.
const ParmVarDecl * getParam() const
Represents a static or instance method of a struct/union/class.
Represents a C++ struct/union/class.
Decl * getLambdaContextDecl() const
Retrieve the declaration that provides additional context for a lambda, when the normal declaration c...
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
bool isLambda() const
Determine whether this class describes a lambda function object.
CXXRecordDecl * getDefinition() const
unsigned getNumBases() const
Retrieves the number of base classes of this class.
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
Represents a C++ nested-name-specifier or a global scope specifier.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Declaration of a class template.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations() const
Retrieve the set of partial specializations of this class template.
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
Represents a class template specialization, which refers to a class template with a given set of temp...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
bool isClassScopeExplicitSpecialization() const
Is this an explicit specialization at class scope (within the class that owns the primary template)?...
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the class template or class template partial specialization which was specialized by this.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate members of the class templa...
void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this class template specialization is actually an instantiation of the given class template...
NamedDecl * getFoundDecl() const
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
bool HasSubstitutionFailure()
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
bool isFileContext() const
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
A reference to a declared variable, function, enum, etc.
SourceLocation getLocation() const
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
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,...
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
bool isParameterPack() const
Whether this declaration is a parameter pack.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
bool isFileContextDecl() const
static Decl * castFromDeclContext(const DeclContext *)
unsigned getTemplateDepth() const
Determine the number of levels of template parameter surrounding this declaration.
DeclContext * getNonTransparentDeclContext()
Return the non transparent context.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setLocation(SourceLocation L)
bool isDefinedOutsideFunctionOrMethod() const
isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...
DeclContext * getDeclContext()
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
The name of a declaration.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
SourceLocation getOuterLocStart() const
Return start of source range taking into account any outer template declarations.
SourceLocation getBeginLoc() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
Represents an extended vector type where either the type or size is dependent.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
bool hasFatalErrorOccurred() const
unsigned getTemplateBacktraceLimit() const
Retrieve the maximum number of template instantiation notes to emit along with a given diagnostic.
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
RAII object that enters a new expression evaluation context.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For an enumeration member that was instantiated from a member enumeration of a templated class,...
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
EnumDecl * getDefinition() const
This represents one expression.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Represents a member of a struct/union/class.
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Represents a function declaration or definition.
ArrayRef< ParmVarDecl * > parameters() const
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
VarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
VarDecl * getExpansion(unsigned I) const
Get an expansion of the parameter pack by index.
VarDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
unsigned getNumExpansions() const
Get the number of parameters in this parameter pack.
SourceLocation getParameterPackLocation() const
Get the location of the parameter pack.
static FunctionParmPackExpr * Create(const ASTContext &Context, QualType T, VarDecl *ParamPack, SourceLocation NameLoc, ArrayRef< VarDecl * > Params)
Represents a prototype with parameter type info, e.g.
ExtProtoInfo getExtProtoInfo() const
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
ArrayRef< ParmVarDecl * > getParams() const
Interesting information about a specific parameter that can't simply be reflected in parameter's type...
FunctionType - C99 6.7.5.3 - Function Declarators.
QualType getReturnType() const
One of these records is kept for each identifier that is lexed.
ArrayRef< TemplateArgument > getTemplateArguments() const
const TypeClass * getTypePtr() const
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
Describes the sequence of initializations required to initialize a given object or reference with a s...
Describes an entity that is being initialized.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
Wrapper for source info for injected class names of class templates.
The injected class name of a C++ class template or class template partial specialization.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
A stack-allocated class that identifies which local variable declaration instantiations are present i...
void SetPartiallySubstitutedPack(NamedDecl *Pack, const TemplateArgument *ExplicitArgs, unsigned NumExplicitArgs)
Note that the given parameter pack has been partially substituted via explicit specification of templ...
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
bool isLocalPackExpansion(const Decl *D)
Determine whether D is a pack expansion created in this scope.
static void deleteScopes(LocalInstantiationScope *Scope, LocalInstantiationScope *Outermost)
deletes the given scope, and all outer scopes, down to the given outermost scope.
void InstantiatedLocal(const Decl *D, Decl *Inst)
void InstantiatedLocalPackArg(const Decl *D, VarDecl *Inst)
void MakeInstantiatedLocalArgPack(const Decl *D)
llvm::PointerUnion< Decl *, DeclArgumentPack * > * findInstantiationOf(const Decl *D)
Find the instantiation of the declaration D within the current instantiation scope.
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.
A pointer to member type per C++ 8.3.3 - Pointers to members.
Provides information a specialization of a member of a class template, which may be a member function...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
Describes a module or submodule.
Data structure that captures multiple levels of template argument lists for use in template instantia...
bool hasTemplateArgument(unsigned Depth, unsigned Index) const
Determine whether there is a non-NULL template argument at the given depth and index.
const ArgList & getInnermost() const
Retrieve the innermost template argument list.
std::pair< Decl *, bool > getAssociatedDecl(unsigned Depth) const
A template-like entity which owns the whole pattern being substituted.
unsigned getNumLevels() const
Determine the number of levels in this template argument list.
unsigned getNumSubstitutedLevels() const
Determine the number of substituted levels in this template argument list.
unsigned getNewDepth(unsigned OldDepth) const
Determine how many of the OldDepth outermost template parameter lists would be removed by substitutin...
void setArgument(unsigned Depth, unsigned Index, TemplateArgument Arg)
Clear out a specific template argument.
bool isRewrite() const
Determine whether we are rewriting template parameters rather than substituting for them.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given stream.
virtual void printName(raw_ostream &OS, const PrintingPolicy &Policy) const
Pretty-print the unqualified name of this declaration.
A C++ nested-name-specifier augmented with source location information.
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isInstantiationDependent() const
Whether this nested name specifier involves a template parameter.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
QualType getExpansionType(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
unsigned getDepth() const
Get the nesting depth of the template parameter.
Represents a pack expansion of types.
Sugar for parentheses used when specifying types.
Represents a parameter to a function.
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
void setDefaultArg(Expr *defarg)
SourceLocation getExplicitObjectParamThisLoc() const
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
void setUninstantiatedDefaultArg(Expr *arg)
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
bool hasUninstantiatedDefaultArg() const
bool hasInheritedDefaultArg() const
void setExplicitObjectParameterLoc(SourceLocation Loc)
Expr * getUninstantiatedDefaultArg()
unsigned getFunctionScopeDepth() const
void setHasInheritedDefaultArg(bool I=true)
PointerType - C99 6.7.5.1 - Pointer Declarators.
[C99 6.4.2.2] - A predefined identifier such as func.
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.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
The collection of all-type qualifiers we support.
void removeObjCLifetime()
Represents a struct/union/class.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Base for LValueReferenceType and RValueReferenceType.
Represents the body of a requires-expression.
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
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.
RAII object used to change the argument pack substitution index within a Sema object.
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
For a defaulted function, the kind of defaulted function that it is.
DefaultedComparisonKind asComparison() const
bool isSpecialMember() const
bool isComparison() const
CXXSpecialMemberKind asSpecialMember() const
A helper class for building up ExtParameterInfos.
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Sema - This implements semantic analysis and AST building for C.
llvm::DenseSet< Module * > LookupModulesCache
Cache of additional modules that should be used for name lookup within the current template instantia...
bool SubstTypeConstraint(TemplateTypeParmDecl *Inst, const TypeConstraint *TC, const MultiLevelTemplateArgumentList &TemplateArgs, bool EvaluateConstraint)
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD)
Determine the kind of defaulting that would be done for a given function.
bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, std::optional< unsigned > &NumExpansions)
Determine whether we could expand a pack expansion with the given set of parameter packs into separat...
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, std::optional< unsigned > NumExpansions, bool ExpectParameterPack, bool EvaluateConstraints=true)
void ActOnFinishCXXNonNestedClass()
NamedDecl * FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, bool FindingInstantiatedContext=false)
Find the instantiation of the given declaration within the current instantiation.
void ActOnFinishDelayedMemberInitializers(Decl *Record)
bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation, NamedDecl *Instantiation, bool InstantiatedFromMember, const NamedDecl *Pattern, const NamedDecl *PatternDef, TemplateSpecializationKind TSK, bool Complain=true)
Determine whether we would be unable to instantiate this template (because it either has no definitio...
void InstantiateClassTemplateSpecializationMembers(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK)
Instantiate the definitions of all of the members of the given class template specialization,...
ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)
Returns the more specialized class template partial specialization according to the rules of partial ...
llvm::DenseSet< std::pair< Decl *, unsigned > > InstantiatingSpecializations
Specializations whose definitions are currently being instantiated.
void deduceOpenCLAddressSpace(ValueDecl *decl)
ExprResult SubstInitializer(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs, bool CXXDirectInit)
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
@ CTAK_Specified
The template argument was specified in the code or was instantiated with some deduced template argume...
bool SubstExprs(ArrayRef< Expr * > Exprs, bool IsCall, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< Expr * > &Outputs)
Substitute the given template arguments into a list of expressions, expanding pack expansions if requ...
StmtResult SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs)
bool InNonInstantiationSFINAEContext
Whether we are in a SFINAE context that is not associated with template instantiation.
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
DiagnosticsEngine & getDiagnostics() const
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, std::optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
ExprResult BuildExpressionFromNonTypeTemplateArgument(const TemplateArgument &Arg, SourceLocation Loc)
ExprResult SubstConstraintExprWithoutSatisfaction(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
ASTContext & getASTContext() const
TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, bool AllowDeducedTST=false)
Perform substitution on the type T with a given set of template arguments.
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool SubstTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentListInfo &Outputs)
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
const LangOptions & getLangOpts() const
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
void InstantiateClassMembers(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiates the definitions of all of the member of the given class, which is an instantiation of a ...
void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD, bool ConstexprOnly=false)
MarkVirtualMembersReferenced - Will mark all members of the given CXXRecordDecl referenced.
DeclarationNameInfo SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, const MultiLevelTemplateArgumentList &TemplateArgs)
Do template substitution on declaration name info.
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
void PrintInstantiationStack()
Prints the current instantiation stack through a series of notes.
void popCodeSynthesisContext()
bool usesPartialOrExplicitSpecialization(SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec)
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
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)
ActOnBaseSpecifier - Parsed a base specifier.
UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations
A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...
bool SubstParmTypes(SourceLocation Loc, ArrayRef< ParmVarDecl * > Params, const FunctionProtoType::ExtParameterInfo *ExtParamInfos, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< QualType > &ParamTypes, SmallVectorImpl< ParmVarDecl * > *OutParams, ExtParameterInfoBuilder &ParamInfos)
Substitute the given template arguments into the given set of parameters, producing the set of parame...
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, const IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
bool CheckFunctionConstraints(const FunctionDecl *FD, ConstraintSatisfaction &Satisfaction, SourceLocation UsageLoc=SourceLocation(), bool ForOverloadResolution=false)
Check whether the given function decl's trailing requires clause is satisfied, if any.
bool CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind ActOnExplicitInstantiationNewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPtOfInstantiation, bool &SuppressNew)
Diagnose cases where we have an explicit template specialization before/after an explicit template in...
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
unsigned NonInstantiationEntries
The number of CodeSynthesisContexts that are not template instantiations and, therefore,...
bool CheckNoInlineAttr(const Stmt *OrigSt, const Stmt *CurSt, const AttributeCommonInfo &A)
bool CheckAlwaysInlineAttr(const Stmt *OrigSt, const Stmt *CurSt, const AttributeCommonInfo &A)
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, Expr *Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member,...
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed.
bool InstantiateInClassInitializer(SourceLocation PointOfInstantiation, FieldDecl *Instantiation, FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the definition of a field from the given pattern.
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given function from its template.
bool SubstDefaultArgument(SourceLocation Loc, ParmVarDecl *Param, const MultiLevelTemplateArgumentList &TemplateArgs, bool ForCallExpr=false)
Substitute the given template arguments into the default argument.
ExprResult SubstConstraintExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
bool hasUncompilableErrorOccurred() const
Whether uncompilable error has occurred.
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
unsigned LastEmittedCodeSynthesisContextDepth
The depth of the context stack at the point when the most recent error or warning was produced.
bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, SmallVectorImpl< TemplateArgument > &SugaredConverted, SmallVectorImpl< TemplateArgument > &CanonicalConverted, CheckTemplateArgumentKind CTAK)
Check that the given template argument corresponds to the given template parameter.
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record)
Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
DiagnosticsEngine & Diags
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier * > Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
SmallVector< Module *, 16 > CodeSynthesisContextLookupModules
Extra modules inspected when performing a lookup during a template instantiation.
ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, ArrayRef< TemplateArgument > TemplateArgs, sema::TemplateDeductionInfo &Info)
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
bool InstantiateEnum(SourceLocation PointOfInstantiation, EnumDecl *Instantiation, EnumDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiate the definition of an enum from a given pattern.
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments.
bool SubstTemplateArgument(const TemplateArgumentLoc &Input, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateArgumentLoc &Output)
void warnStackExhausted(SourceLocation Loc)
Warn that the stack is nearly exhausted.
ExprResult BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Given a non-type template argument that refers to a declaration and the type of its corresponding non...
bool SubstBaseSpecifiers(CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
Perform substitution on the base class specifiers of the given class template specialization.
void PerformDependentDiagnostics(const DeclContext *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
ASTMutationListener * getASTMutationListener() const
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
TypeSourceInfo * SubstFunctionDeclType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext, Qualifiers ThisTypeQuals, bool EvaluateConstraints=true)
A form of SubstType intended specifically for instantiating the type of a FunctionDecl.
Encodes a location in the source.
A trivial tuple used to represent a source range.
Represents a C++11 static_assert declaration.
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
Represents a reference to a non-type template parameter that has been substituted with a template arg...
std::optional< unsigned > getPackIndex() const
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
QualType getParameterType(const ASTContext &Ctx) const
Determine the substituted type of the template parameter.
NonTypeTemplateParmDecl * getParameter() const
Expr * getReplacement() const
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
SourceLocation getParameterPackLocation() const
Retrieve the location of the parameter pack name.
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
A structure for storing an already-substituted template template parameter pack.
Wrapper for substituted template type parameters.
Represents the result of substituting a set of types for a template type parameter pack.
Wrapper for substituted template type parameters.
Represents the declaration of a struct/union/class/enum.
void setTagKind(TagKind TK)
SourceRange getBraceRange() const
SourceLocation getInnerLocStart() const
Return SourceLocation representing start of source range ignoring outer template declarations.
StringRef getKindName() const
void startDefinition()
Starts the definition of this tag declaration.
TagKind getTagKind() const
void setBraceRange(SourceRange R)
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
A template argument list.
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Location wrapper for a TemplateArgument.
const TemplateArgument & getArgument() const
Represents a template argument.
ArrayRef< TemplateArgument > getPackAsArray() const
Return the array of arguments in this template argument pack.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
QualType getAsType() const
Retrieve the type for a type template argument.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
bool isNull() const
Determine whether this template argument has no value.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ Pack
The template argument is actually a parameter pack.
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
void enableLateAttributeInstantiation(Sema::LateInstantiatedAttrVec *LA)
void disableLateAttributeInstantiation()
delayed_var_partial_spec_iterator delayed_var_partial_spec_end()
delayed_partial_spec_iterator delayed_partial_spec_begin()
Return an iterator to the beginning of the set of "delayed" partial specializations,...
void setEvaluateConstraints(bool B)
SmallVectorImpl< std::pair< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > >::iterator delayed_var_partial_spec_iterator
LocalInstantiationScope * getStartingScope() const
VarTemplatePartialSpecializationDecl * InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a variable template partial specialization.
SmallVectorImpl< std::pair< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > >::iterator delayed_partial_spec_iterator
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
delayed_partial_spec_iterator delayed_partial_spec_end()
Return an iterator to the end of the set of "delayed" partial specializations, which must be passed t...
delayed_var_partial_spec_iterator delayed_var_partial_spec_begin()
ClassTemplatePartialSpecializationDecl * InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl *ClassTemplate, ClassTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a class template partial specialization.
The base class of all kinds of template declarations (e.g., class, function, etc.).
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
bool isNull() const
Determine whether this template name is NULL.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
TemplateName getNameToSubstitute() const
Get the template name to substitute when this template name is used as a template template argument.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation getTemplateLoc() const
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
SourceLocation getLocation() const
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set.
Represents a type template specialization; the template must be a class template, a type alias templa...
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
unsigned getDepth() const
Get the nesting depth of the template parameter.
Declaration of a template type parameter.
bool isParameterPack() const
Returns whether this is a parameter pack.
void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)
Wrapper for template type parameters.
bool isParameterPack() const
unsigned getIndex() const
unsigned getDepth() const
Declaration of an alias template.
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
ConceptDecl * getNamedConcept() const
Expr * getImmediatelyDeclaredConstraint() const
Get the immediately-declared constraint expression introduced by this type-constraint,...
const NestedNameSpecifierLoc & getNestedNameSpecifierLoc() const
const DeclarationNameInfo & getConceptNameInfo() const
ConceptReference * getConceptReference() const
void setLocStart(SourceLocation L)
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
void reserve(size_t Requested)
Ensures that this buffer has at least as much capacity as described.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
void pushTrivial(ASTContext &Context, QualType T, SourceLocation Loc)
Pushes 'T' with all locations pointing to 'Loc'.
Base wrapper for a particular "section" of type source info.
QualType getType() const
Get the type for which this source info wrapper provides information.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
TypeLoc IgnoreParens() const
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
unsigned getFullDataSize() const
Returns the size of the type source info data block.
SourceLocation getEndLoc() const
Get the end source location.
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
SourceLocation getNameLoc() const
void setNameLoc(SourceLocation Loc)
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
The base class of the type hierarchy.
bool isReferenceType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
bool isStaticDataMember() const
Determines whether this is a static data member.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization,...
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Declaration of a variable template.
Represents a variable template specialization, which refers to a variable template with a given set o...
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...
bool isClassScopeExplicitSpecialization() const
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
Represents a GCC generic vector type.
A requires-expression requirement which queries the validity and properties of an expression ('simple...
SubstitutionDiagnostic * getExprSubstitutionDiagnostic() const
bool isExprSubstitutionFailure() const
const ReturnTypeRequirement & getReturnTypeRequirement() const
SourceLocation getNoexceptLoc() const
A requires-expression requirement which is satisfied when a general constraint expression is satisfie...
const ASTConstraintSatisfaction & getConstraintSatisfaction() const
bool hasInvalidConstraint() const
Expr * getConstraintExpr() const
StringRef getInvalidConstraintEntity()
A static requirement that can be used in a requires-expression to check properties of types and expre...
A requires-expression requirement which queries the existence of a type name or type template special...
bool isSubstitutionFailure() const
SubstitutionDiagnostic * getSubstitutionDiagnostic() const
TypeSourceInfo * getType() const
Provides information about an attempted template argument deduction, whose success or failure was des...
TemplateArgumentList * takeCanonical()
SourceLocation getLocation() const
Returns the location at which template argument is occurring.
bool hasSFINAEDiagnostic() const
Is a SFINAE diagnostic available?
void takeSFINAEDiagnostic(PartialDiagnosticAt &PD)
Take ownership of the SFINAE diagnostic.
Defines the clang::TargetInfo interface.
Requirement::SubstitutionDiagnostic * createSubstDiagAt(Sema &S, SourceLocation Location, EntityPrinter Printer)
create a Requirement::SubstitutionDiagnostic with only a SubstitutedEntity and DiagLoc using Sema's a...
llvm::function_ref< void(llvm::raw_ostream &)> EntityPrinter
Attr * instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
Attr * instantiateTemplateAttributeForDecl(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
The JSON file list parser is used to communicate input to InstallAPI.
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
NamedDecl * getAsNamedDecl(TemplateParameter P)
bool isStackNearlyExhausted()
Determine whether the stack is nearly exhausted.
bool isGenericLambdaCallOperatorOrStaticInvokerSpecialization(const DeclContext *DC)
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
TagTypeKind
The kind of a tag type.
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema's representation of template deduction information to the form used in overload-can...
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
std::pair< unsigned, unsigned > getDepthAndIndex(NamedDecl *ND)
Retrieve the depth and index of a template parameter.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const FunctionProtoType * T
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
TemplateDeductionResult
Describes the result of template argument deduction.
@ Success
Template argument deduction was successful.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ None
No keyword precedes the qualified type name.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
@ EST_Uninstantiated
not instantiated yet
@ EST_None
no exception specification
__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
SourceLocation RAngleLoc
The source location of the right angle bracket ('>').
SourceLocation LAngleLoc
The source location of the left angle bracket ('<').
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
Holds information about the various types of exception specification.
ExceptionSpecificationType Type
The kind of exception specification this is.
ExceptionSpecInfo ExceptionSpec
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
SourceRange InstantiationRange
The source range that covers the construct that cause the instantiation, e.g., the template-id that c...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
bool SavedInNonInstantiationSFINAEContext
Was the enclosing context a non-instantiation SFINAE context?
const TemplateArgument * TemplateArgs
The list of template arguments we are substituting, if they are not part of the entity.
sema::TemplateDeductionInfo * DeductionInfo
The template deduction info object associated with the substitution or checking of explicit or deduce...
NamedDecl * Template
The template (or partial specialization) in which we are performing the instantiation,...
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
SynthesisKind
The kind of template instantiation we are performing.
@ MarkingClassDllexported
We are marking a class as __dllexport.
@ RequirementParameterInstantiation
@ DefaultTemplateArgumentInstantiation
We are instantiating a default argument for a template parameter.
@ ExplicitTemplateArgumentSubstitution
We are substituting explicit template arguments provided for a function template.
@ DefaultTemplateArgumentChecking
We are checking the validity of a default template argument that has been used when naming a template...
@ InitializingStructuredBinding
We are initializing a structured binding.
@ ExceptionSpecInstantiation
We are instantiating the exception specification for a function template which was deferred until it ...
@ NestedRequirementConstraintsCheck
We are checking the satisfaction of a nested requirement of a requires expression.
@ BuildingBuiltinDumpStructCall
We are building an implied call from __builtin_dump_struct.
@ ParameterMappingSubstitution
@ DefiningSynthesizedFunction
We are defining a synthesized function (such as a defaulted special member).
@ Memoization
Added for Template instantiation observation.
@ ConstraintNormalization
@ LambdaExpressionSubstitution
We are substituting into a lambda expression.
@ TypeAliasTemplateInstantiation
We are instantiating a type alias template declaration.
@ BuildingDeductionGuides
We are building deduction guides for a class.
@ DeducedTemplateArgumentSubstitution
We are substituting template argument determined as part of template argument deduction for either a ...
@ PriorTemplateArgumentSubstitution
We are substituting prior template arguments into a new template parameter.
@ ExceptionSpecEvaluation
We are computing the exception specification for a defaulted special member function.
@ TemplateInstantiation
We are instantiating a template declaration.
@ DeclaringSpecialMember
We are declaring an implicit special member function.
@ DeclaringImplicitEqualityComparison
We are declaring an implicit 'operator==' for a defaulted 'operator<=>'.
@ DefaultFunctionArgumentInstantiation
We are instantiating a default argument for a function.
@ RewritingOperatorAsSpaceship
We are rewriting a comparison operator in terms of an operator<=>.
@ RequirementInstantiation
We are instantiating a requirement of a requires expression.
Decl * Entity
The entity that is being synthesized.
bool isInstantiationRecord() const
Determines whether this template is an actual instantiation that should be counted toward the maximum...
A stack object to be created when performing template instantiation.
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity, SourceRange InstantiationRange=SourceRange())
Note that we are instantiating a class template, function template, variable template,...
void Clear()
Note that we have finished instantiating this template.
bool isAlreadyInstantiating() const
Determine whether we are already instantiating this specialization in some surrounding active instant...
void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)