34 #include "llvm/ADT/SmallBitVector.h" 35 #include "llvm/ADT/SmallString.h" 36 #include "llvm/ADT/StringExtras.h" 39 using namespace clang;
47 return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
55 for (
Scope *TempParamScope = S->getTemplateParamParent(); TempParamScope;
56 TempParamScope = TempParamScope->getParent()->getTemplateParamParent()) {
66 if (
auto *LSI = dyn_cast<LambdaScopeInfo>(FSI)) {
67 if (!LSI->TemplateParams.empty()) {
68 ParamsAtDepth(LSI->AutoTemplateParameterDepth);
71 if (LSI->GLTemplateParameterList) {
72 ParamsAtDepth(LSI->GLTemplateParameterList->getDepth());
81 getInventedParameterInfos()) {
82 if (!Info.TemplateParams.empty()) {
83 ParamsAtDepth(Info.AutoTemplateParameterDepth);
98 bool AllowFunctionTemplates,
99 bool AllowDependent) {
102 if (isa<TemplateDecl>(D)) {
103 if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(D))
121 if (Record->isInjectedClassName()) {
122 Record = cast<CXXRecordDecl>(Record->getDeclContext());
123 if (Record->getDescribedClassTemplate())
124 return Record->getDescribedClassTemplate();
127 = dyn_cast<ClassTemplateSpecializationDecl>(Record))
128 return Spec->getSpecializedTemplate();
137 if (AllowDependent && isa<UnresolvedUsingValueDecl>(D))
144 bool AllowFunctionTemplates,
145 bool AllowDependent) {
149 if (!getAsTemplateNameDecl(Orig, AllowFunctionTemplates, AllowDependent))
156 bool AllowFunctionTemplates,
158 bool AllowNonTemplateFunctions) {
160 if (getAsTemplateNameDecl(*I, AllowFunctionTemplates, AllowDependent))
162 if (AllowNonTemplateFunctions &&
163 isa<FunctionDecl>((*I)->getUnderlyingDecl()))
172 bool hasTemplateKeyword,
175 bool EnteringContext,
177 bool &MemberOfUnknownSpecialization,
178 bool Disambiguation) {
179 assert(getLangOpts().
CPlusPlus &&
"No template names in C!");
182 MemberOfUnknownSpecialization =
false;
184 switch (Name.getKind()) {
191 Name.OperatorFunctionId.Operator);
205 LookupResult R(*
this, TName, Name.getBeginLoc(), LookupOrdinaryName);
206 if (LookupTemplateName(R, S, SS, ObjectType, EnteringContext,
217 return AssumedTemplate == AssumedTemplateKind::FoundNothing
226 if (R.isAmbiguous()) {
229 bool AnyFunctionTemplates =
false;
231 if (
NamedDecl *FoundTemplate = getAsTemplateNameDecl(FoundD)) {
232 if (isa<FunctionTemplateDecl>(FoundTemplate))
233 AnyFunctionTemplates =
true;
243 if (!D && !AnyFunctionTemplates) {
244 R.suppressDiagnostics();
251 FilterAcceptableTemplateNames(R);
261 unsigned ResultCount = R.end() - R.begin();
262 if (!D && ResultCount > 1) {
269 R.suppressDiagnostics();
272 D = getAsTemplateNameDecl(*R.begin());
273 assert(D &&
"unambiguous result is not a template name");
276 if (isa<UnresolvedUsingValueDecl>(D)) {
278 MemberOfUnknownSpecialization =
true;
287 hasTemplateKeyword, TD);
292 if (isa<FunctionTemplateDecl>(TD)) {
296 R.suppressDiagnostics();
298 assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
299 isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||
300 isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD));
308 TemplateResult = TemplateTy::make(Template);
316 bool MemberOfUnknownSpecialization =
false;
322 if (LookupTemplateName(R, S, SS,
QualType(),
324 MemberOfUnknownSpecialization))
327 if (R.
empty())
return false;
354 if (!SS || !SS->
isSet() || !isDependentScopeSpecifier(*SS) ||
355 computeDeclContext(*SS))
361 Diag(IILoc, diag::err_template_kw_missing)
373 bool EnteringContext,
374 bool &MemberOfUnknownSpecialization,
377 bool AllowTypoCorrection) {
387 MemberOfUnknownSpecialization =
false;
389 bool IsDependent =
false;
390 if (!ObjectType.
isNull()) {
393 assert(SS.
isEmpty() &&
"ObjectType and scope specifier cannot coexist");
394 LookupCtx = computeDeclContext(ObjectType);
398 "Caller should have completed object type");
422 LookupCtx = computeDeclContext(SS, EnteringContext);
423 IsDependent = !LookupCtx && isDependentScopeSpecifier(SS);
426 if (LookupCtx && RequireCompleteDeclContext(SS, LookupCtx))
430 bool ObjectTypeSearchedInScope =
false;
431 bool AllowFunctionTemplatesInLookup =
true;
437 LookupQualifiedName(Found, LookupCtx);
461 LookupName(Found, S);
463 if (!ObjectType.
isNull()) {
467 AllowFunctionTemplatesInLookup =
false;
468 ObjectTypeSearchedInScope =
true;
488 getLangOpts().CPlusPlus20 &&
490 return isa<FunctionDecl>(ND->getUnderlyingDecl());
492 if (AllFunctions || (Found.
empty() && !IsDependent)) {
497 ? AssumedTemplateKind::FoundNothing
498 : AssumedTemplateKind::FoundFunctions;
504 if (Found.
empty() && !IsDependent && AllowTypoCorrection) {
512 FilterCCC.WantExpressionKeywords =
false;
513 FilterCCC.WantRemainingKeywords =
false;
514 FilterCCC.WantCXXNamedCasts =
true;
517 &SS, FilterCCC, CTK_ErrorRecovery, LookupCtx)) {
518 if (
auto *ND = Corrected.getFoundDecl())
520 FilterAcceptableTemplateNames(Found);
523 }
else if (!Found.
empty()) {
526 std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
527 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
528 Name.getAsString() == CorrectedStr;
529 diagnoseTypo(Corrected, PDiag(diag::err_no_member_template_suggest)
530 << Name << LookupCtx << DroppedSpecifier
533 diagnoseTypo(Corrected, PDiag(diag::err_no_template_suggest) << Name);
541 FilterAcceptableTemplateNames(Found, AllowFunctionTemplatesInLookup);
544 MemberOfUnknownSpecialization =
true;
550 if (ExampleLookupResult && RequiredTemplate) {
551 Diag(Found.
getNameLoc(), diag::err_template_kw_refers_to_non_template)
556 diag::note_template_kw_refers_to_non_template)
564 if (S && !ObjectType.
isNull() && !ObjectTypeSearchedInScope &&
565 !getLangOpts().CPlusPlus11) {
575 LookupName(FoundOuter, S);
578 FilterAcceptableTemplateNames(FoundOuter,
false);
581 if (FoundOuter.empty()) {
584 }
else if (FoundOuter.isAmbiguous() || !FoundOuter.isSingleResult() ||
586 getAsTemplateNameDecl(FoundOuter.getFoundDecl()))) {
599 diag::ext_nested_name_member_ref_lookup_ambiguous)
603 diag::note_ambig_member_ref_object_type)
605 Diag(FoundOuter.getFoundDecl()->getLocation(),
606 diag::note_ambig_member_ref_scope);
629 bool MissingTemplateKeyword =
false;
632 if (
auto *DRE = dyn_cast<DeclRefExpr>(
TemplateName.get())) {
633 NameInfo = DRE->getNameInfo();
634 SS.
Adopt(DRE->getQualifierLoc());
635 LookupKind = LookupOrdinaryName;
636 Found = DRE->getFoundDecl();
637 }
else if (
auto *ME = dyn_cast<MemberExpr>(
TemplateName.get())) {
638 NameInfo = ME->getMemberNameInfo();
639 SS.
Adopt(ME->getQualifierLoc());
640 LookupKind = LookupMemberName;
641 LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();
642 Found = ME->getMemberDecl();
643 }
else if (
auto *DSDRE =
644 dyn_cast<DependentScopeDeclRefExpr>(
TemplateName.get())) {
645 NameInfo = DSDRE->getNameInfo();
646 SS.
Adopt(DSDRE->getQualifierLoc());
647 MissingTemplateKeyword =
true;
648 }
else if (
auto *DSME =
649 dyn_cast<CXXDependentScopeMemberExpr>(
TemplateName.get())) {
650 NameInfo = DSME->getMemberNameInfo();
651 SS.
Adopt(DSME->getQualifierLoc());
652 MissingTemplateKeyword =
true;
654 llvm_unreachable(
"unexpected kind of potential template name");
659 if (MissingTemplateKeyword) {
668 TemplateCandidateFilter(
Sema &S) : S(S) {
669 WantTypeSpecifiers =
false;
670 WantExpressionKeywords =
false;
671 WantRemainingKeywords =
false;
672 WantCXXNamedCasts =
true;
674 bool ValidateCandidate(
const TypoCorrection &Candidate)
override {
680 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
681 return std::make_unique<TemplateCandidateFilter>(*
this);
686 TemplateCandidateFilter CCC(*
this);
687 if (
TypoCorrection Corrected = CorrectTypo(NameInfo, LookupKind, S, &SS, CCC,
688 CTK_ErrorRecovery, LookupCtx)) {
689 auto *ND = Corrected.getFoundDecl();
691 ND = getAsTemplateNameDecl(ND);
692 if (ND || Corrected.isKeyword()) {
694 std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
695 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
696 Name.getAsString() == CorrectedStr;
697 diagnoseTypo(Corrected,
698 PDiag(diag::err_non_template_in_member_template_id_suggest)
699 << Name << LookupCtx << DroppedSpecifier
702 diagnoseTypo(Corrected,
703 PDiag(diag::err_non_template_in_template_id_suggest)
708 diag::note_non_template_in_template_id_found);
713 Diag(NameInfo.
getLoc(), diag::err_non_template_in_template_id)
716 Diag(Found->
getLocation(), diag::note_non_template_in_template_id_found);
726 bool isAddressOfOperand,
741 bool MightBeCxx11UnevalField =
742 getLangOpts().CPlusPlus11 && isUnevaluatedContext();
747 IsEnum = dyn_cast_or_null<EnumType>(NNS->getAsType());
749 if (!MightBeCxx11UnevalField && !isAddressOfOperand && !IsEnum &&
750 isa<CXXMethodDecl>(DC) && cast<CXXMethodDecl>(DC)->isInstance()) {
751 QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType();
755 NamedDecl *FirstQualifierInScope =
nullptr;
758 Context,
nullptr, ThisType,
true,
760 FirstQualifierInScope, NameInfo, TemplateArgs);
763 return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
777 Context, QualifierLoc, TemplateKWLoc, NameInfo, TemplateArgs);
785 bool InstantiatedFromMember,
790 assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||
791 isa<VarDecl>(Instantiation));
793 bool IsEntityBeingDefined =
false;
794 if (
const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
795 IsEntityBeingDefined = TD->isBeingDefined();
797 if (PatternDef && !IsEntityBeingDefined) {
799 if (!hasVisibleDefinition(const_cast<NamedDecl*>(PatternDef), &SuggestedDef,
802 bool Recover = Complain && !isSFINAEContext();
804 diagnoseMissingImport(PointOfInstantiation, SuggestedDef,
811 if (!Complain || (PatternDef && PatternDef->
isInvalidDecl()))
816 if (
TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
819 Diag(PointOfInstantiation,
820 diag::err_template_instantiate_within_definition)
826 }
else if (InstantiatedFromMember) {
827 if (isa<FunctionDecl>(Instantiation)) {
828 Diag(PointOfInstantiation,
829 diag::err_explicit_instantiation_undefined_member)
832 Note = diag::note_explicit_instantiation_here;
834 assert(isa<TagDecl>(Instantiation) &&
"Must be a TagDecl!");
835 Diag(PointOfInstantiation,
836 diag::err_implicit_instantiate_member_undefined)
838 Note = diag::note_member_declared_at;
841 if (isa<FunctionDecl>(Instantiation)) {
842 Diag(PointOfInstantiation,
843 diag::err_explicit_instantiation_undefined_func_template)
845 Note = diag::note_explicit_instantiation_here;
846 }
else if (isa<TagDecl>(Instantiation)) {
847 Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
850 Note = diag::note_template_decl_here;
852 assert(isa<VarDecl>(Instantiation) &&
"Must be a VarDecl!");
853 if (isa<VarTemplateSpecializationDecl>(Instantiation)) {
854 Diag(PointOfInstantiation,
855 diag::err_explicit_instantiation_undefined_var_template)
859 Diag(PointOfInstantiation,
860 diag::err_explicit_instantiation_undefined_member)
863 Note = diag::note_explicit_instantiation_here;
890 unsigned DiagId = getLangOpts().MSVCCompat ? diag::ext_template_param_shadow
891 : diag::err_template_param_shadow;
892 Diag(Loc, DiagId) << cast<NamedDecl>(PrevDecl)->getDeclName();
900 if (
TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
901 D = Temp->getTemplatedDecl();
909 assert(
Kind == Template &&
910 "Only template template arguments can be pack expansions here");
911 assert(getAsTemplate().get().containsUnexpandedParameterPack() &&
912 "Template template argument pack expansion without packs");
914 Result.EllipsisLoc = EllipsisLoc;
949 llvm_unreachable(
"Unhandled parsed template argument");
956 for (
unsigned I = 0,
Last = TemplateArgsIn.size(); I !=
Last; ++I)
979 assert(TInfo &&
"template argument with no location");
987 EllipsisLoc = PET.getEllipsisLoc();
988 TL = PET.getPatternLoc();
993 SS.
Adopt(ET.getQualifierLoc());
994 TL = ET.getNamedTypeLoc();
998 TemplateName Name = DTST.getTypePtr()->getTemplateName();
1002 Name.getAsTemplateDecl());
1004 DTST.getTemplateNameLoc());
1006 Result = Result.getTemplatePackExpansion(EllipsisLoc);
1034 unsigned Depth,
unsigned Position,
1037 bool HasTypeConstraint) {
1038 assert(S->isTemplateParamScope() &&
1039 "Template type parameter not in template parameter scope!");
1041 bool IsParameterPack = EllipsisLoc.
isValid();
1044 KeyLoc, ParamNameLoc,
Depth, Position,
1045 ParamName, Typename, IsParameterPack,
1050 if (
auto *LSI = getEnclosingLambda())
1051 LSI->LocalPacks.push_back(Param);
1058 IdResolver.AddDecl(Param);
1064 if (DefaultArg && IsParameterPack) {
1065 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1066 DefaultArg =
nullptr;
1072 GetTypeFromParser(DefaultArg, &DefaultTInfo);
1074 assert(DefaultTInfo &&
"expected source information for type");
1077 if (DiagnoseUnexpandedParameterPack(ParamNameLoc, DefaultTInfo,
1078 UPPC_DefaultArgument))
1082 if (CheckTemplateArgument(Param, DefaultTInfo)) {
1101 return TemplateArgs;
1116 diag::err_type_constraint_non_type_concept);
1122 if (!WereArgsSpecified &&
1125 diag::err_type_constraint_missing_arguments) << CD;
1134 return AttachTypeConstraint(
1139 ConstrainedParameter, EllipsisLoc);
1142 template<
typename ArgumentLocAppender>
1157 Appender(ConstraintArgs);
1166 NamedConcept, NamedConcept, &ConstraintArgs);
1168 return ImmediatelyDeclaredConstraint;
1184 ImmediatelyDeclaredConstraint.
get(), BO_LAnd,
1185 EllipsisLoc,
nullptr,
1205 *TemplateArgs) :
nullptr;
1211 *
this, NS, NameInfo, NamedConcept,
1214 ParamAsArgument, ConstrainedParameter->
getLocation(),
1217 for (
const auto &ArgLoc : TemplateArgs->
arguments())
1218 ConstraintArgs.addArgument(ArgLoc);
1220 if (ImmediatelyDeclaredConstraint.isInvalid())
1225 NamedConcept, ArgsAsWritten,
1226 ImmediatelyDeclaredConstraint.get());
1235 diag::err_unsupported_placeholder_constraint)
1251 for (
unsigned I = 0, C = TL.
getNumArgs(); I != C; ++I)
1252 ConstraintArgs.addArgument(TL.
getArgLoc(I));
1254 if (ImmediatelyDeclaredConstraint.
isInvalid() ||
1255 !ImmediatelyDeclaredConstraint.
isUsable())
1275 TSI = SubstAutoTypeSourceInfo(TSI, Context.
DependentTy);
1278 return CheckNonTypeTemplateParameterType(TSI->
getType(), Loc);
1288 if (RequireCompleteType(Loc, T, diag::err_template_nontype_parm_incomplete))
1296 Diag(Loc, diag::err_template_nontype_parm_rvalue_ref) << T;
1306 Diag(Loc, diag::err_template_nontype_parm_bad_type) << T;
1311 if (RequireLiteralType(Loc, T, diag::err_template_nontype_parm_not_literal))
1314 Diag(Loc, diag::err_template_nontype_parm_not_structural) << T;
1321 for (
const FieldDecl *FD : RD->fields()) {
1323 Diag(FD->getLocation(), diag::note_not_structural_non_public) << T << 0;
1326 if (FD->isMutable()) {
1327 Diag(FD->getLocation(), diag::note_not_structural_mutable_field) << T;
1330 if (FD->getType()->isRValueReferenceType()) {
1331 Diag(FD->getLocation(), diag::note_not_structural_rvalue_ref_field)
1338 for (
const auto &BaseSpec : RD->bases()) {
1339 if (BaseSpec.getAccessSpecifier() !=
AS_public) {
1340 Diag(BaseSpec.getBaseTypeLoc(), diag::note_not_structural_non_public)
1351 for (
const FieldDecl *FD : RD->fields()) {
1354 SubLoc = FD->getLocation();
1362 for (
const auto &BaseSpec : RD->bases()) {
1365 SubLoc = BaseSpec.getBaseTypeLoc();
1373 assert(
Kind != -1 &&
"couldn't find reason why type is not structural");
1374 Diag(SubLoc, diag::note_not_structural_subobject)
1375 << T <<
Kind << SubType;
1388 Diag(Loc, diag::err_variably_modified_nontype_template_param)
1434 if (RequireStructuralType(T, Loc))
1441 Diag(Loc, diag::err_template_nontype_parm_bad_structural_type) << T;
1445 Diag(Loc, diag::warn_cxx17_compat_template_nontype_parm_type) << T;
1457 auto CheckValidDeclSpecifiers = [
this, &D] {
1471 Diag(Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
1508 CheckValidDeclSpecifiers();
1512 diag::warn_cxx14_compat_template_nontype_parm_auto_type)
1516 assert(S->isTemplateParamScope() &&
1517 "Non-type template parameter not in template parameter scope!");
1518 bool Invalid =
false;
1526 CheckFunctionOrTemplateParamDeclarator(S, D);
1537 if (TL.isConstrained())
1545 if (
auto *LSI = getEnclosingLambda())
1546 LSI->LocalPacks.push_back(Param);
1554 IdResolver.AddDecl(Param);
1560 if (
Default && IsParameterPack) {
1561 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1568 if (DiagnoseUnexpandedParameterPack(
Default, UPPC_DefaultArgument))
1573 CheckTemplateArgument(Param, Param->
getType(),
Default, Converted);
1599 assert(S->isTemplateParamScope() &&
1600 "Template template parameter not in template parameter scope!");
1603 bool IsParameterPack = EllipsisLoc.
isValid();
1607 Depth, Position, IsParameterPack,
1612 if (
auto *LSI = getEnclosingLambda())
1613 LSI->LocalPacks.push_back(Param);
1621 IdResolver.AddDecl(Param);
1624 if (Params->
size() == 0) {
1633 if (IsParameterPack && !
Default.isInvalid()) {
1634 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1649 Diag(DefaultArg.
getLocation(), diag::err_template_arg_not_valid_template)
1655 if (DiagnoseUnexpandedParameterPack(DefaultArg.
getLocation(),
1657 UPPC_DefaultArgument))
1676 Expr *RequiresClause) {
1678 Diag(ExportLoc, diag::warn_template_export_unsupported);
1681 Context, TemplateLoc, LAngleLoc,
1682 llvm::makeArrayRef(Params.data(), Params.size()),
1683 RAngleLoc, RequiresClause);
1699 assert(TemplateParams && TemplateParams->
size() > 0 &&
1700 "No template parameters");
1701 assert(TUK != TUK_Reference &&
"Can only declare or define class templates");
1702 bool Invalid =
false;
1705 if (CheckTemplateDeclScope(S, TemplateParams))
1709 assert(
Kind !=
TTK_Enum &&
"can't build template of enumerated type");
1713 Diag(KWLoc, diag::err_template_unnamed_class);
1722 (SS.
isEmpty() && TUK == TUK_Friend)
1723 ? LookupTagName : LookupOrdinaryName,
1724 forRedeclarationInCurContext());
1726 SemanticContext = computeDeclContext(SS,
true);
1727 if (!SemanticContext) {
1731 Diag(NameLoc, TUK == TUK_Friend
1732 ? diag::warn_template_qualified_friend_ignored
1733 : diag::err_template_qualified_declarator_no_match)
1735 return TUK != TUK_Friend;
1738 if (RequireCompleteDeclContext(SS, SemanticContext))
1746 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
1748 }
else if (TUK != TUK_Friend && TUK != TUK_Reference)
1749 diagnoseQualifiedDeclaration(SS, SemanticContext, Name, NameLoc,
false);
1751 LookupQualifiedName(
Previous, SemanticContext);
1753 SemanticContext = CurContext;
1759 if (TUK != TUK_Friend &&
1760 DiagnoseClassNameShadow(SemanticContext,
1772 PrevDecl = (*
Previous.begin())->getUnderlyingDecl();
1776 DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
1784 dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
1789 if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) &&
1790 cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
1793 = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
1794 if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
1796 = cast<ClassTemplateSpecializationDecl>(PrevDecl)
1797 ->getSpecializedTemplate();
1801 if (TUK == TUK_Friend) {
1820 PrevDecl = PrevClassTemplate =
nullptr;
1821 SemanticContext = OutermostContext;
1825 Previous.clear(LookupOrdinaryName);
1829 LookupQualifiedName(
Previous, LookupContext);
1835 PrevDecl = (*
Previous.begin())->getUnderlyingDecl();
1838 }
else if (PrevDecl &&
1839 !isDeclInScope(
Previous.getRepresentativeDecl(), SemanticContext,
1841 PrevDecl = PrevClassTemplate =
nullptr;
1843 if (
auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
1844 PrevDecl ?
Previous.getRepresentativeDecl() :
nullptr)) {
1846 !(PrevClassTemplate &&
1849 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
1850 Diag(Shadow->getTargetDecl()->getLocation(),
1851 diag::note_using_decl_target);
1852 Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
1854 PrevDecl = PrevClassTemplate =
nullptr;
1858 if (PrevClassTemplate) {
1862 if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1863 !TemplateParameterListsAreEqual(TemplateParams,
1875 if (!isAcceptableTagRedeclaration(PrevRecordDecl,
Kind,
1876 TUK == TUK_Definition, KWLoc, Name)) {
1877 Diag(KWLoc, diag::err_use_with_wrong_tag)
1885 if (TUK == TUK_Definition) {
1890 if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
1893 auto *Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();
1894 assert(Tmpl &&
"original definition of a class template is not a " 1896 makeMergedDefinitionVisible(Hidden);
1897 makeMergedDefinitionVisible(Tmpl);
1899 Diag(NameLoc, diag::err_redefinition) << Name;
1900 Diag(Def->getLocation(), diag::note_previous_definition);
1907 }
else if (PrevDecl) {
1913 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
1922 if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1923 CheckTemplateParameterList(
1928 (SS.
isSet() && SemanticContext && SemanticContext->
isRecord() &&
1930 ? TPC_ClassTemplateMember
1931 : TUK == TUK_Friend ? TPC_FriendClassTemplate : TPC_ClassTemplate,
1938 if (!SS.
isInvalid() && !Invalid && !PrevClassTemplate) {
1939 Diag(NameLoc, TUK == TUK_Friend ? diag::err_friend_decl_does_not_match
1940 : diag::err_member_decl_does_not_match)
1941 << Name << SemanticContext <<
true << SS.
getRange();
1951 bool ShouldAddRedecl
1952 = !(TUK == TUK_Friend && CurContext->isDependentContext());
1956 PrevClassTemplate && ShouldAddRedecl ?
1960 if (NumOuterTemplateParamLists > 0)
1962 Context, llvm::makeArrayRef(OuterTemplateParamLists,
1963 NumOuterTemplateParamLists));
1967 if (TUK == TUK_Definition && (!SkipBody || !SkipBody->
ShouldSkip)) {
1968 AddAlignmentAttributesForRecord(NewClass);
1969 AddMsStructLayoutForRecord(NewClass);
1977 if (ShouldAddRedecl)
1982 if (ModulePrivateLoc.
isValid())
1988 assert(T->
isDependentType() &&
"Class template type is not dependent?");
1993 if (PrevClassTemplate &&
1999 SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS);
2005 if (TUK == TUK_Definition && (!SkipBody || !SkipBody->
ShouldSkip))
2008 ProcessDeclAttributeList(S, NewClass,
Attr);
2010 if (PrevClassTemplate)
2013 AddPushedVisibilityAttribute(NewClass);
2014 inferGslOwnerPointerAttribute(NewClass);
2016 if (TUK != TUK_Friend) {
2021 PushOnScopeChains(NewTemplate, Outer);
2031 if (!CurContext->isDependentContext()) {
2034 if (
Scope *EnclosingScope = getScopeForDeclContext(S, DC))
2035 PushOnScopeChains(NewTemplate, EnclosingScope,
2040 Context, CurContext, NewClass->
getLocation(), NewTemplate, FriendLoc);
2042 CurContext->addDecl(Friend);
2045 if (PrevClassTemplate)
2046 CheckRedeclarationModuleOwnership(NewTemplate, PrevClassTemplate);
2053 ActOnDocumentableDecl(NewTemplate);
2064 class ExtractTypeForDeductionGuide
2070 ExtractTypeForDeductionGuide(
2073 :
Base(SemaRef), MaterializedTypedefs(MaterializedTypedefs) {}
2078 ASTContext &Context = SemaRef.getASTContext();
2088 if (isa<TypeAliasDecl>(OrigDecl))
2093 assert(isa<TypedefDecl>(OrigDecl) &&
"Not a Type alias or typedef");
2098 MaterializedTypedefs.push_back(
Decl);
2111 struct ConvertConstructorToDeductionGuideTransform {
2112 ConvertConstructorToDeductionGuideTransform(
Sema &S,
2114 : SemaRef(S), Template(Template) {}
2148 AllParams.reserve(TemplateParams->
size() + InnerParams->
size());
2149 AllParams.insert(AllParams.begin(),
2150 TemplateParams->
begin(), TemplateParams->
end());
2151 SubstArgs.reserve(InnerParams->
size());
2160 NamedDecl *NewParam = transformTemplateParameter(Param, Args);
2163 AllParams.push_back(NewParam);
2168 SemaRef.
Context, InnerParams->getTemplateLoc(),
2169 InnerParams->getLAngleLoc(), AllParams, InnerParams->getRAngleLoc(),
2185 assert(FPTL &&
"no prototype for constructor declaration");
2193 QualType NewType = transformFunctionProtoType(TLB, FPTL, Params, Args,
2194 MaterializedTypedefs);
2212 DeductionGuideName, EPI);
2220 for (
auto T : ParamTypes) {
2222 SemaRef.
Context, DC, Loc, Loc,
nullptr, T,
2225 FPTL.
setParam(Params.size(), NewParam);
2226 Params.push_back(NewParam);
2239 if (
auto *TTP = dyn_cast<TemplateTypeParmDecl>(TemplateParam)) {
2243 SemaRef.
Context, DC, TTP->getBeginLoc(), TTP->getLocation(),
2244 0, Depth1IndexAdjustment + TTP->getIndex(),
2245 TTP->getIdentifier(), TTP->wasDeclaredWithTypename(),
2246 TTP->isParameterPack(), TTP->hasTypeConstraint(),
2247 TTP->isExpandedParameterPack() ?
2249 if (
const auto *TC = TTP->getTypeConstraint()) {
2251 const auto *ArgsAsWritten = TC->getTemplateArgsAsWritten();
2252 if (!ArgsAsWritten ||
2253 SemaRef.
Subst(ArgsAsWritten->getTemplateArgs(),
2254 ArgsAsWritten->NumTemplateArgs, TransformedArgs,
2257 TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
2258 TC->getNamedConcept(), ArgsAsWritten ? &TransformedArgs :
nullptr,
2260 NewTTP->isParameterPack()
2261 ? cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
2265 if (TTP->hasDefaultArgument()) {
2267 SemaRef.
SubstType(TTP->getDefaultArgumentInfo(), Args,
2268 TTP->getDefaultArgumentLoc(), TTP->getDeclName());
2269 if (InstantiatedDefaultArg)
2270 NewTTP->setDefaultArgument(InstantiatedDefaultArg);
2277 if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TemplateParam))
2278 return transformTemplateParameterImpl(TTP, Args);
2280 return transformTemplateParameterImpl(
2281 cast<NonTypeTemplateParmDecl>(TemplateParam), Args);
2283 template<
typename TemplateParmDecl>
2285 transformTemplateParameterImpl(TemplateParmDecl *OldParam,
2290 cast<TemplateParmDecl>(SemaRef.
SubstDecl(OldParam, DC, Args));
2291 assert(NewParam->getDepth() == 0 &&
"unexpected template param depth");
2292 NewParam->setPosition(NewParam->getPosition() + Depth1IndexAdjustment);
2296 QualType transformFunctionProtoType(
2307 transformFunctionTypeParam(OldParam, Args, MaterializedTypedefs);
2310 ParamTypes.push_back(NewParam->
getType());
2311 Params.push_back(NewParam);
2333 ReturnType, ParamTypes, TL.
getBeginLoc(), DeductionGuideName, EPI);
2334 if (Result.isNull())
2343 for (
unsigned I = 0, E = NewTL.
getNumParams(); I != E; ++I)
2358 SemaRef.
SubstType(PackTL.getPatternLoc(), Args,
2360 if (!NewDI)
return nullptr;
2363 PackTL.getTypePtr()->getNumExpansions());
2374 NewDI = ExtractTypeForDeductionGuide(SemaRef, MaterializedTypedefs)
2384 NewDefArg =
new (SemaRef.
Context)
2418 TInfo->
getType(), TInfo, LocEnd);
2420 Guide->setParams(Params);
2422 for (
auto *Param : Params)
2423 Param->setDeclContext(Guide);
2424 for (
auto *TD : MaterializedTypedefs)
2425 TD->setDeclContext(Guide);
2428 SemaRef.
Context, DC, Loc, DeductionGuideName, TemplateParams, Guide);
2429 GuideTemplate->setImplicit();
2430 Guide->setDescribedFunctionTemplate(GuideTemplate);
2432 if (isa<CXXRecordDecl>(DC)) {
2438 return GuideTemplate;
2447 TemplateDecl *DescribedTemplate = DefRecord->getDescribedClassTemplate();
2448 Template = DescribedTemplate ? DescribedTemplate : Template;
2455 ConvertConstructorToDeductionGuideTransform Transform(
2456 *
this, cast<ClassTemplateDecl>(Template));
2457 if (!isCompleteType(Loc, Transform.DeducedType))
2462 auto Existing = DC->
lookup(Transform.DeductionGuideName);
2463 for (
auto *D : Existing)
2464 if (D->isImplicit())
2475 if (BuildingDeductionGuides.
isInvalid())
2482 bool AddedAny =
false;
2483 for (
NamedDecl *D : LookupConstructors(Transform.Primary)) {
2484 D = D->getUnderlyingDecl();
2485 if (D->isInvalidDecl() || D->isImplicit())
2487 D = cast<NamedDecl>(D->getCanonicalDecl());
2489 auto *FTD = dyn_cast<FunctionTemplateDecl>(D);
2491 dyn_cast_or_null<CXXConstructorDecl>(FTD ? FTD->getTemplatedDecl() : D);
2497 Transform.transformConstructor(FTD, CD);
2506 Transform.buildSimpleDeductionGuide(None);
2510 cast<CXXDeductionGuideDecl>(
2511 cast<FunctionTemplateDecl>(
2512 Transform.buildSimpleDeductionGuide(Transform.DeducedType))
2513 ->getTemplatedDecl())
2514 ->setIsCopyDeductionCandidate();
2542 diag::warn_cxx98_compat_template_parameter_default_in_function_template
2543 : diag::ext_template_parameter_default_in_function_template)
2552 S.
Diag(ParamLoc, diag::err_template_parameter_default_template_member)
2561 S.
Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
2570 llvm_unreachable(
"Invalid TemplateParamListContext!");
2583 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
2588 if (TC->hasExplicitTemplateArgs())
2589 for (
auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
2597 if (!NTTP->isParameterPack() &&
2599 NTTP->getTypeSourceInfo(),
2607 = dyn_cast<TemplateTemplateParmDecl>(
P))
2647 bool Invalid =
false;
2655 bool SawDefaultArgument =
false;
2661 OldParam = OldParams->
begin();
2663 bool RemoveDefaultArguments =
false;
2665 NewParamEnd = NewParams->
end();
2666 NewParam != NewParamEnd; ++NewParam) {
2668 bool RedundantDefaultArg =
false;
2673 bool MissingDefaultArg =
false;
2676 bool SawParameterPack =
false;
2679 = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
2681 if (NewTypeParm->hasDefaultArgument() &&
2683 NewTypeParm->getLocation(),
2684 NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
2686 NewTypeParm->removeDefaultArgument();
2690 = OldParams? cast<TemplateTypeParmDecl>(*OldParam) :
nullptr;
2691 if (NewTypeParm->isParameterPack()) {
2692 assert(!NewTypeParm->hasDefaultArgument() &&
2693 "Parameter packs can't have a default argument!");
2694 SawParameterPack =
true;
2696 NewTypeParm->hasDefaultArgument() &&
2699 NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
2700 SawDefaultArgument =
true;
2701 RedundantDefaultArg =
true;
2702 PreviousDefaultArgLoc = NewDefaultLoc;
2706 NewTypeParm->setInheritedDefaultArgument(Context, OldTypeParm);
2708 }
else if (NewTypeParm->hasDefaultArgument()) {
2709 SawDefaultArgument =
true;
2710 PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
2711 }
else if (SawDefaultArgument)
2712 MissingDefaultArg =
true;
2714 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
2716 if (!NewNonTypeParm->isParameterPack() &&
2717 DiagnoseUnexpandedParameterPack(NewNonTypeParm->getLocation(),
2718 NewNonTypeParm->getTypeSourceInfo(),
2719 UPPC_NonTypeTemplateParameterType)) {
2725 if (NewNonTypeParm->hasDefaultArgument() &&
2727 NewNonTypeParm->getLocation(),
2728 NewNonTypeParm->getDefaultArgument()->getSourceRange())) {
2729 NewNonTypeParm->removeDefaultArgument();
2734 = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) :
nullptr;
2735 if (NewNonTypeParm->isParameterPack()) {
2736 assert(!NewNonTypeParm->hasDefaultArgument() &&
2737 "Parameter packs can't have a default argument!");
2738 if (!NewNonTypeParm->isPackExpansion())
2739 SawParameterPack =
true;
2741 NewNonTypeParm->hasDefaultArgument() &&
2744 NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
2745 SawDefaultArgument =
true;
2746 RedundantDefaultArg =
true;
2747 PreviousDefaultArgLoc = NewDefaultLoc;
2751 NewNonTypeParm->setInheritedDefaultArgument(Context, OldNonTypeParm);
2753 }
else if (NewNonTypeParm->hasDefaultArgument()) {
2754 SawDefaultArgument =
true;
2755 PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
2756 }
else if (SawDefaultArgument)
2757 MissingDefaultArg =
true;
2760 = cast<TemplateTemplateParmDecl>(*NewParam);
2777 = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) :
nullptr;
2780 "Parameter packs can't have a default argument!");
2782 SawParameterPack =
true;
2783 }
else if (OldTemplateParm &&
2789 SawDefaultArgument =
true;
2790 RedundantDefaultArg =
true;
2791 PreviousDefaultArgLoc = NewDefaultLoc;
2796 PreviousDefaultArgLoc
2799 SawDefaultArgument =
true;
2800 PreviousDefaultArgLoc
2802 }
else if (SawDefaultArgument)
2803 MissingDefaultArg =
true;
2809 if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
2810 (TPC == TPC_ClassTemplate || TPC == TPC_VarTemplate ||
2811 TPC == TPC_TypeAliasTemplate)) {
2812 Diag((*NewParam)->getLocation(),
2813 diag::err_template_param_pack_must_be_last_template_parameter);
2817 if (RedundantDefaultArg) {
2821 Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
2822 Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
2824 }
else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) {
2830 Diag((*NewParam)->getLocation(),
2831 diag::err_template_param_default_arg_missing);
2832 Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
2834 RemoveDefaultArguments =
true;
2845 if (RemoveDefaultArguments) {
2847 NewParamEnd = NewParams->
end();
2848 NewParam != NewParamEnd; ++NewParam) {
2850 TTP->removeDefaultArgument();
2852 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
2853 NTTP->removeDefaultArgument();
2855 cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
2875 bool IgnoreNonTypeDependent;
2880 DependencyChecker(
unsigned Depth,
bool IgnoreNonTypeDependent)
2881 :
Depth(
Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
2885 : IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(
false) {
2888 Depth = PD->getDepth();
2890 dyn_cast<NonTypeTemplateParmDecl>(ND)) {
2891 Depth = PD->getDepth();
2893 Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
2898 if (ParmDepth >=
Depth) {
2906 bool TraverseStmt(
Stmt *S, DataRecursionQueue *Q =
nullptr) {
2911 if (
auto *E = dyn_cast_or_null<Expr>(S))
2912 if (IgnoreNonTypeDependent && !E->isTypeDependent())
2914 return super::TraverseStmt(S, Q);
2917 bool TraverseTypeLoc(
TypeLoc TL) {
2918 if (IgnoreNonTypeDependent && !TL.
isNull() &&
2921 return super::TraverseTypeLoc(TL);
2930 return IgnoreNonTypeDependent || !Matches(T->
getDepth());
2936 if (Matches(PD->getDepth()))
2938 return super::TraverseTemplateName(N);
2943 dyn_cast<NonTypeTemplateParmDecl>(E->
getDecl()))
2944 if (Matches(PD->getDepth(), E->
getExprLoc()))
2946 return super::VisitDeclRefExpr(E);
2968 if (!Params->
size())
2971 DependencyChecker Checker(Params,
false);
2972 Checker.TraverseType(T);
2973 return Checker.Match;
2983 if (
const Type *CurType = NNS->getAsType()) {
2989 NNSLoc = NNSLoc.getPrefix();
3032 bool &IsMemberSpecialization,
bool &Invalid,
bool SuppressDiagnostic) {
3033 IsMemberSpecialization =
false;
3043 = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS,
true)))
3055 NestedTypes.push_back(T);
3061 = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
3062 if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
3064 ExplicitSpecLoc = Spec->getLocation();
3067 }
else if (Record->getTemplateSpecializationKind()
3069 ExplicitSpecLoc = Record->getLocation();
3082 if (
TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
3128 std::reverse(NestedTypes.begin(), NestedTypes.end());
3136 bool SawNonEmptyTemplateParameterList =
false;
3138 auto CheckExplicitSpecialization = [&](
SourceRange Range,
bool Recovery) {
3139 if (SawNonEmptyTemplateParameterList) {
3140 if (!SuppressDiagnostic)
3141 Diag(DeclLoc, diag::err_specialize_member_of_template)
3142 << !Recovery << Range;
3144 IsMemberSpecialization =
false;
3151 auto DiagnoseMissingExplicitSpecialization = [&] (
SourceRange Range) {
3153 if (CheckExplicitSpecialization(Range,
true))
3158 if (!ParamLists.empty())
3159 ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
3161 ExpectedTemplateLoc = DeclStartLoc;
3163 if (!SuppressDiagnostic)
3164 Diag(DeclLoc, diag::err_template_spec_needs_header)
3171 for (
unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
3173 T = NestedTypes[TypeIdx];
3176 bool NeedEmptyTemplateHeader =
false;
3179 bool NeedNonemptyTemplateHeader =
false;
3192 = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) {
3193 ExpectedTemplateParams = Partial->getTemplateParameters();
3194 NeedNonemptyTemplateHeader =
true;
3195 }
else if (Record->isDependentType()) {
3196 if (Record->getDescribedClassTemplate()) {
3197 ExpectedTemplateParams = Record->getDescribedClassTemplate()
3198 ->getTemplateParameters();
3199 NeedNonemptyTemplateHeader =
true;
3202 = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
3208 NeedEmptyTemplateHeader =
true;
3211 }
else if (Record->getTemplateSpecializationKind()) {
3212 if (Record->getTemplateSpecializationKind()
3214 TypeIdx == NumTypes - 1)
3215 IsMemberSpecialization =
true;
3221 if (
TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
3223 NeedNonemptyTemplateHeader =
true;
3228 NeedNonemptyTemplateHeader =
false;
3238 if (
ParamIdx < ParamLists.size()) {
3239 if (ParamLists[
ParamIdx]->size() == 0) {
3244 SawNonEmptyTemplateParameterList =
true;
3247 if (NeedEmptyTemplateHeader) {
3250 if (TypeIdx == NumTypes - 1)
3251 IsMemberSpecialization =
true;
3253 if (
ParamIdx < ParamLists.size()) {
3254 if (ParamLists[
ParamIdx]->size() > 0) {
3256 if (!SuppressDiagnostic)
3258 diag::err_template_param_list_matches_nontemplate)
3261 ParamLists[
ParamIdx]->getRAngleLoc())
3273 if (DiagnoseMissingExplicitSpecialization(
3280 if (NeedNonemptyTemplateHeader) {
3286 if (
ParamIdx < ParamLists.size() &&
3288 ExpectedTemplateParams =
nullptr;
3293 if (
ParamIdx < ParamLists.size()) {
3295 if (ExpectedTemplateParams &&
3296 !TemplateParameterListsAreEqual(ParamLists[
ParamIdx],
3297 ExpectedTemplateParams,
3298 !SuppressDiagnostic, TPL_TemplateMatch))
3302 CheckTemplateParameterList(ParamLists[
ParamIdx],
nullptr,
3303 TPC_ClassTemplateMember))
3310 if (!SuppressDiagnostic)
3311 Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
3322 if (
ParamIdx >= ParamLists.size()) {
3323 if (TemplateId && !IsFriend) {
3339 if (
ParamIdx < ParamLists.size() - 1) {
3340 bool HasAnyExplicitSpecHeader =
false;
3341 bool AllExplicitSpecHeaders =
true;
3342 for (
unsigned I =
ParamIdx, E = ParamLists.size() - 1; I != E; ++I) {
3343 if (ParamLists[I]->size() == 0)
3344 HasAnyExplicitSpecHeader =
true;
3346 AllExplicitSpecHeaders =
false;
3349 if (!SuppressDiagnostic)
3351 AllExplicitSpecHeaders ? diag::warn_template_spec_extra_headers
3352 : diag::err_template_spec_extra_headers)
3354 ParamLists[ParamLists.size() - 2]->getRAngleLoc());
3359 if (ExplicitSpecLoc.
isValid() && HasAnyExplicitSpecHeader &&
3360 !SuppressDiagnostic)
3361 Diag(ExplicitSpecLoc,
3362 diag::note_explicit_template_spec_does_not_need_header)
3363 << NestedTypes.back();
3368 if (!AllExplicitSpecHeaders)
3379 if (ParamLists.back()->size() == 0 &&
3386 return ParamLists.back();
3390 if (
TemplateDecl *Template = Name.getAsTemplateDecl()) {
3392 << (isa<FunctionTemplateDecl>(Template)
3394 : isa<ClassTemplateDecl>(Template)
3396 : isa<VarTemplateDecl>(Template)
3398 : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
3407 Diag((*I)->getLocation(), diag::note_template_declared_here)
3408 << 0 << (*I)->getDeclName();
3427 if (!Converted[1].getAsType()->isIntegralType(Context)) {
3428 SemaRef.
Diag(TemplateArgs[1].getLocation(),
3429 diag::err_integer_sequence_integral_element_type);
3438 SemaRef.
Diag(TemplateArgs[2].getLocation(),
3439 diag::err_integer_sequence_negative_length);
3447 SyntheticTemplateArgs.
addArgument(TemplateArgs[1]);
3449 for (
llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
3453 TA, ArgTy, TemplateArgs[2].getLocation()));
3458 TemplateLoc, SyntheticTemplateArgs);
3465 assert(Converted.size() == 2 &&
3466 "__type_pack_element should be given an index and a parameter pack");
3471 assert(Index >= 0 &&
"the index used with __type_pack_element should be of " 3472 "type std::size_t, and hence be non-negative");
3473 if (Index >= Ts.pack_size()) {
3474 SemaRef.
Diag(TemplateArgs[0].getLocation(),
3475 diag::err_type_pack_element_out_of_bounds);
3480 auto Nth = std::next(Ts.pack_begin(), Index.getExtValue());
3481 return Nth->getAsType();
3483 llvm_unreachable(
"unexpected BuiltinTemplateDecl!");
3500 if (BinOp->getOpcode() == BO_LAnd) {
3508 Terms.push_back(Clause);
3517 if (!BinOp)
return Cond;
3519 if (BinOp->getOpcode() != BO_LOr)
return Cond;
3522 Expr *LHS = BinOp->getLHS();
3524 if (!InnerBinOp)
return Cond;
3526 if (InnerBinOp->getOpcode() != BO_EQ ||
3527 !isa<IntegerLiteral>(InnerBinOp->getRHS()))
3537 if (MacroName ==
"CONCEPT_REQUIRES" || MacroName ==
"CONCEPT_REQUIRES_")
3538 return BinOp->getRHS();
3548 class FailedBooleanConditionPrinterHelper :
public PrinterHelper {
3553 bool handledStmt(
Stmt *E, raw_ostream &OS)
override {
3554 const auto *DR = dyn_cast<DeclRefExpr>(E);
3555 if (DR && DR->getQualifier()) {
3558 DR->getQualifier()->print(OS, Policy,
true);
3562 if (
const auto *IV = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
3577 std::pair<Expr *, std::string>
3586 Expr *FailedCond =
nullptr;
3587 for (
Expr *Term : Terms) {
3591 if (isa<CXXBoolLiteralExpr>(TermAsWritten) ||
3592 isa<IntegerLiteral>(TermAsWritten))
3601 if (Term->EvaluateAsBooleanCondition(Succeeded, Context) &&
3603 FailedCond = TermAsWritten;
3610 std::string Description;
3612 llvm::raw_string_ostream Out(Description);
3615 FailedBooleanConditionPrinterHelper Helper(Policy);
3616 FailedCond->
printPretty(Out, &Helper, Policy, 0,
"\n",
nullptr);
3618 return { FailedCond, Description };
3625 = Name.getUnderlying().getAsDependentTemplateName();
3636 if (Name.getAsAssumedTemplateName() &&
3637 resolveAssumedTemplateNameAsType(
nullptr, Name, TemplateLoc))
3641 if (!Template || isa<FunctionTemplateDecl>(Template) ||
3642 isa<VarTemplateDecl>(Template) || isa<ConceptDecl>(Template)) {
3645 if (Name.getAsSubstTemplateTemplateParmPack())
3648 Diag(TemplateLoc, diag::err_template_id_not_a_type)
3650 NoteAllFoundTemplates(Name);
3657 if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
3665 dyn_cast<TypeAliasTemplateDecl>(Template)) {
3689 if (CanonType.
isNull()) {
3694 if (
auto DeductionInfo = isSFINAEContext()) {
3695 if (*DeductionInfo &&
3696 (*DeductionInfo)->hasSFINAEDiagnostic() &&
3697 (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
3698 diag::err_typename_nested_not_found_enable_if &&
3699 TemplateArgs[0].getArgument().getKind()
3702 std::string FailedDescription;
3703 std::tie(FailedCond, FailedDescription) =
3704 findFailedBooleanCondition(TemplateArgs[0].getSourceExpression());
3709 (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);
3713 (*DeductionInfo)->addSFINAEDiagnostic(
3715 PDiag(diag::err_typename_nested_not_found_requirement)
3716 << FailedDescription
3724 }
else if (Name.isDependent() ||
3726 TemplateArgs, Converted)) {
3742 if (isa<ClassTemplateDecl>(Template)) {
3745 if (Ctx->isFileContext())
break;
3749 if (!Record)
continue;
3753 if (!isa<ClassTemplatePartialSpecializationDecl>(Record) &&
3760 QualType Injected = cast<InjectedClassNameType>(ICNT)
3761 ->getInjectedSpecializationType();
3774 = dyn_cast<ClassTemplateDecl>(Template)) {
3777 void *InsertPos =
nullptr;
3779 = ClassTemplate->findSpecialization(Converted, InsertPos);
3785 Context, ClassTemplate->getTemplatedDecl()->getTagKind(),
3786 ClassTemplate->getDeclContext(),
3787 ClassTemplate->getTemplatedDecl()->getBeginLoc(),
3788 ClassTemplate->getLocation(), ClassTemplate, Converted,
nullptr);
3789 ClassTemplate->AddSpecialization(
Decl, InsertPos);
3790 if (ClassTemplate->isOutOfLine())
3795 ClassTemplate->getTemplatedDecl()->hasAttrs()) {
3800 InstantiateAttrsForDecl(TemplateArgLists,
3801 ClassTemplate->getTemplatedDecl(),
Decl);
3806 (void)DiagnoseUseOfDecl(
Decl, TemplateLoc);
3809 assert(isa<RecordType>(CanonType) &&
3810 "type of non-dependent specialization is not a RecordType");
3811 }
else if (
auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
3829 auto *ATN = Name.getAsAssumedTemplateName();
3830 assert(ATN &&
"not an assumed template name");
3831 II = ATN->getDeclName().getAsIdentifierInfo();
3833 if (!resolveAssumedTemplateNameAsType(S, Name, NameLoc,
false)) {
3835 ParsedName = TemplateTy::make(Name);
3847 assert(ATN &&
"not an assumed template name");
3855 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
3856 return std::make_unique<CandidateCallback>(*
this);
3861 CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S,
nullptr,
3862 FilterCCC, CTK_ErrorRecovery);
3864 diagnoseTypo(Corrected, PDiag(diag::err_no_template_suggest)
3871 Diag(R.getNameLoc(), diag::err_no_template) << R.getLookupName();
3880 bool IsCtorOrDtorName,
bool IsClassName) {
3884 if (!IsCtorOrDtorName && !IsClassName && SS.
isSet()) {
3885 DeclContext *LookupCtx = computeDeclContext(SS,
false);
3893 if (!LookupCtx && isDependentScopeSpecifier(SS)) {
3900 return ActOnTypenameType(
nullptr,
SourceLocation(), SS, TemplateKWLoc,
3901 TemplateD, TemplateII, TemplateIILoc, LAngleLoc,
3902 TemplateArgsIn, RAngleLoc);
3909 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
3910 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
3913 ? diag::err_out_of_line_qualified_id_type_names_constructor
3914 : diag::ext_out_of_line_qualified_id_type_names_constructor)
3922 resolveAssumedTemplateNameAsType(S, Template, TemplateIILoc))
3927 translateTemplateArguments(TemplateArgsIn, TemplateArgs);
3932 DTN->getQualifier(),
3933 DTN->getIdentifier(),
3945 for (
unsigned I = 0, N = SpecTL.
getNumArgs(); I != N; ++I)
3950 QualType Result = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
3951 if (Result.isNull())
3962 for (
unsigned i = 0, e = SpecTL.
getNumArgs(); i != e; ++i)
3996 translateTemplateArguments(TemplateArgsIn, TemplateArgs);
4005 DTN->getQualifier(),
4006 DTN->getIdentifier(),
4019 for (
unsigned I = 0, N = SpecTL.
getNumArgs(); I != N; ++I)
4030 Diag(TemplateLoc, diag::err_tag_reference_non_tag)
4031 << TAT << NTK_TypeAliasTemplate << TagKind;
4032 Diag(TAT->getLocation(), diag::note_declared_at);
4035 QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
4036 if (Result.isNull())
4044 assert(
Id &&
"templated class must have an identifier");
4046 if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition,
4048 Diag(TagLoc, diag::err_use_with_wrong_tag)
4063 for (
unsigned i = 0, e = SpecTL.
getNumArgs(); i != e; ++i)
4097 return TPT && !
Type.hasQualifiers() &&
4106 dyn_cast<NonTypeTemplateParmDecl>(DRE->
getDecl());
4112 dyn_cast_or_null<TemplateTemplateParmDecl>(
4116 llvm_unreachable(
"unexpected kind of template argument");
4121 if (Params->
size() != Args.size())
4126 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
4145 template<
typename PartialSpecDecl>
4147 if (Partial->getDeclContext()->isDependentContext())
4156 auto *Template = Partial->getSpecializedTemplate();
4157 S.
Diag(Partial->getLocation(),
4158 diag::ext_partial_spec_not_more_specialized_than_primary)
4159 << isa<VarTemplateDecl>(Template);
4161 if (Info.hasSFINAEDiagnostic()) {
4164 Info.takeSFINAEDiagnostic(
Diag);
4168 diag::note_partial_spec_not_more_specialized_than_primary)
4175 Partial->getAssociatedConstraints(PartialAC);
4182 const llvm::SmallBitVector &DeducibleParams) {
4183 for (
unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
4184 if (!DeducibleParams[I]) {
4197 template<
typename PartialSpecDecl>
4199 PartialSpecDecl *Partial) {
4212 auto *TemplateParams = Partial->getTemplateParameters();
4213 llvm::SmallBitVector DeducibleParams(TemplateParams->
size());
4215 TemplateParams->
getDepth(), DeducibleParams);
4217 if (!DeducibleParams.all()) {
4218 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
4219 S.
Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
4220 << isa<VarTemplatePartialSpecializationDecl>(Partial)
4221 << (NumNonDeducible > 1)
4223 Partial->getTemplateArgsAsWritten()->RAngleLoc);
4244 llvm::SmallBitVector DeducibleParams(TemplateParams->
size());
4245 MarkDeducedTemplateParameters(TD, DeducibleParams);
4246 for (
unsigned I = 0; I != TemplateParams->
size(); ++I) {
4248 auto *Param = TemplateParams->
getParam(I);
4250 DeducibleParams[I] =
true;
4253 if (!DeducibleParams.all()) {
4254 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
4255 Diag(TD->
getLocation(), diag::err_deduction_guide_template_not_deducible)
4256 << (NumNonDeducible > 1);
4267 "Variable template specialization is declared with a template it.");
4280 dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());
4283 if (
auto *OTS = Name.getAsOverloadedTemplate())
4284 FnTemplate = *OTS->begin();
4286 FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());
4295 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
4296 if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
4297 UPPC_PartialSpecialization))
4303 if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
4311 if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, VarTemplate,
4312 TemplateArgs.
size(), Converted))
4317 if (!Name.isDependent() &&
4320 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
4333 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
4335 << (SC !=
SC_Extern && !CurContext->isRecord())
4343 void *InsertPos =
nullptr;
4372 cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
4376 TemplateNameLoc, TemplateParams, VarTemplate, DI->
getType(), DI, SC,
4377 Converted, TemplateArgs);
4380 VarTemplate->AddPartialSpecialization(Partial, InsertPos);
4388 CheckTemplatePartialSpecialization(Partial);
4393 Context, VarTemplate->
getDeclContext(), TemplateKWLoc, TemplateNameLoc,
4394 VarTemplate, DI->
getType(), DI, SC, Converted);
4419 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
4423 diag::note_instantiation_required_here)
4444 LookupResult PrevSpec(*
this, GetNameForDeclarator(D), LookupOrdinaryName,
4445 forRedeclarationInCurContext());
4459 struct PartialSpecMatchResult {
4469 assert(Template &&
"A variable template id without template?");
4473 if (CheckTemplateArgumentList(
4474 Template, TemplateNameLoc,
4475 const_cast<TemplateArgumentListInfo &>(TemplateArgs),
false,
4487 void *InsertPos =
nullptr;
4489 Converted, InsertPos)) {
4490 checkSpecializationVisibility(TemplateNameLoc, Spec);
4503 bool AmbiguousPartialSpec =
false;
4518 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
4531 Matched.push_back(PartialSpecMatchResult());
4532 Matched.back().Partial = Partial;
4533 Matched.back().Args = Info.take();
4537 if (Matched.size() >= 1) {
4539 if (Matched.size() == 1) {
4552 PEnd = Matched.end();
4554 if (getMoreSpecializedPartialSpecialization(
P->Partial, Best->Partial,
4555 PointOfInstantiation) ==
4563 PEnd = Matched.end();
4565 if (
P != Best && getMoreSpecializedPartialSpecialization(
4566 P->Partial, Best->Partial,
4567 PointOfInstantiation) != Best->Partial) {
4568 AmbiguousPartialSpec =
true;
4575 InstantiationPattern = Best->Partial;
4576 InstantiationArgs = Best->Args;
4588 Template, InstantiationPattern, *InstantiationArgs, TemplateArgs,
4589 Converted, TemplateNameLoc );
4593 if (AmbiguousPartialSpec) {
4596 Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
4601 Diag(
P.Partial->getLocation(), diag::note_partial_spec_match)
4602 << getTemplateArgumentBindingsText(
P.Partial->getTemplateParameters(),
4608 dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
4609 Decl->setInstantiationOf(D, InstantiationArgs);
4611 checkSpecializationVisibility(TemplateNameLoc,
Decl);
4613 assert(
Decl &&
"No variable template specialization?");
4625 if (
Decl.isInvalid())
4637 return BuildDeclarationNameExpr(SS, NameInfo, Var,
4638 nullptr, TemplateArgs);
4643 Diag(Loc, diag::err_template_missing_args)
4644 << (
int)getTemplateNameKindForDiagnostics(Name) << Name;
4646 Diag(TD->getLocation(), diag::note_template_decl_here)
4647 << TD->getTemplateParameters()->getSourceRange();
4658 assert(NamedConcept &&
"A concept template id without a template?");
4661 if (CheckTemplateArgumentList(NamedConcept, ConceptNameInfo.
getLoc(),
4662 const_cast<TemplateArgumentListInfo&>(*TemplateArgs),
4668 bool AreArgsDependent =
4671 if (!AreArgsDependent &&
4681 TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,
4683 AreArgsDependent ? nullptr : &Satisfaction);
4702 assert(!R.
isAmbiguous() &&
"ambiguous lookup when building templateid");
4706 if (!TemplateArgs && !isa<FunctionTemplateDecl>(TD)) {
4716 TemplateKWLoc, TemplateArgs);
4736 RequiresADL, TemplateArgs,
4749 assert(TemplateArgs || TemplateKWLoc.
isValid());
4751 if (!(DC = computeDeclContext(SS,
false)) ||
4752 DC->isDependentContext() ||
4753 RequireCompleteDeclContext(SS, DC))
4754 return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
4756 bool MemberOfUnknownSpecialization;
4759 false, MemberOfUnknownSpecialization,
4773 Diag(NameInfo.
getLoc(), diag::err_template_kw_refers_to_class_template)
4776 Diag(Temp->getLocation(), diag::note_referenced_class_template);
4780 return BuildTemplateIdExpr(SS, TemplateKWLoc, R,
false, TemplateArgs);
4802 bool EnteringContext,
4804 bool AllowInjectedClassName) {
4805 if (TemplateKWLoc.
isValid() && S && !S->getTemplateParamParent())
4807 getLangOpts().CPlusPlus11 ?
4808 diag::warn_cxx98_compat_template_outside_of_template :
4809 diag::ext_template_outside_of_template)
4818 LookupCtx = computeDeclContext(SS, EnteringContext);
4819 else if (ObjectType)
4820 LookupCtx = computeDeclContext(GetTypeFromParser(ObjectType));
4838 bool MemberOfUnknownSpecialization;
4840 ObjectType, EnteringContext, Result,
4841 MemberOfUnknownSpecialization);
4844 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
4845 if (!AllowInjectedClassName && SS.
isNotEmpty() && LookupRD &&
4847 Name.Identifier && LookupRD->getIdentifier() == Name.Identifier) {
4857 Diag(Name.getBeginLoc(),
4858 diag::ext_out_of_line_qualified_id_type_names_constructor)
4866 if (!MemberOfUnknownSpecialization) {
4873 LookupOrdinaryName);
4879 : TemplateNameIsRequired;
4880 if (!LookupTemplateName(R, S, SS, ObjectType.get(), EnteringContext, MOUS,
4881 RTK,
nullptr,
false) &&
4884 Diag(Name.getBeginLoc(), diag::err_no_member)
4887 Diag(Name.getBeginLoc(), diag::err_undeclared_use)
4895 switch (Name.getKind()) {
4897 Result = TemplateTy::make(
4903 Qualifier, Name.OperatorFunctionId.Operator));
4917 Diag(Name.getBeginLoc(),
4918 diag::err_template_kw_refers_to_dependent_non_template)
4919 << GetNameFromUnqualifiedId(Name).getName() << Name.getSourceRange()
4920 << TemplateKWLoc.
isValid() << TemplateKWLoc;
4946 diagnoseMissingTemplateArguments(Name, SR.
getEnd());
4956 dyn_cast<DependentScopeDeclRefExpr>(Arg.
getAsExpr())) {
4957 SS.
Adopt(ArgExpr->getQualifierLoc());
4958 NameInfo = ArgExpr->getNameInfo();
4960 dyn_cast<CXXDependentScopeMemberExpr>(Arg.
getAsExpr())) {
4961 if (ArgExpr->isImplicitAccess()) {
4962 SS.
Adopt(ArgExpr->getQualifierLoc());
4963 NameInfo = ArgExpr->getMemberNameInfo();
4968 LookupResult Result(*
this, NameInfo, LookupOrdinaryName);
4969 LookupParsedName(Result, CurScope, &SS);
4971 if (Result.getAsSingle<
TypeDecl>() ||
4972 Result.getResultKind() ==
4974 assert(SS.
getScopeRep() &&
"dependent scope expr must has a scope!");
4977 Diag(Loc, getLangOpts().MSVCCompat
4978 ? diag::ext_ms_template_type_arg_missing_typename
4979 : diag::err_template_arg_must_be_type_suggest)
5009 Diag(SR.
getBegin(), diag::err_template_arg_must_be_type) << SR;
5016 if (CheckTemplateArgument(Param, TSI))
5025 if (getLangOpts().ObjCAutoRefCount &&
5071 Param, Template, Converted,
5081 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
5086 SemaRef.
SubstType(ArgType, TemplateArgLists,
5123 Param, Template, Converted,
5133 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
5186 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
5216 bool &HasDefaultArg) {
5217 HasDefaultArg =
false;
5223 HasDefaultArg =
true;
5236 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
5240 HasDefaultArg =
true;
5254 = cast<TemplateTemplateParmDecl>(Param);
5258 HasDefaultArg =
true;
5283 if (ETLoc.getTypePtr()->getKeyword() !=
ETK_None)
5286 QualLoc = ETLoc.getQualifierLoc();
5287 TLoc = ETLoc.getNamedTypeLoc();
5293 QualLoc, InjLoc.getNameLoc());
5301 dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))
5304 QualLoc, RecLoc.getNameLoc());
5340 unsigned ArgumentPackIndex,
5345 return CheckTemplateTypeArgument(TTP, Arg, Converted);
5352 QualType NTTPType = NTTP->getType();
5353 if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
5354 NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
5357 !isa<TemplateTemplateParmDecl>(Template) &&
5373 NTTPType = SubstType(PET->getPattern(),
5375 NTTP->getLocation(),
5376 NTTP->getDeclName());
5378 NTTPType = SubstType(NTTPType,
5380 NTTP->getLocation(),
5381 NTTP->getDeclName());
5387 NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
5388 NTTP->getLocation());
5395 llvm_unreachable(
"Should never see a NULL template argument here");
5399 unsigned CurSFINAEErrors = NumSFINAEErrors;
5406 if (CurSFINAEErrors < NumSFINAEErrors)
5416 Converted.push_back(Result);
5450 Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
5462 E = CheckTemplateArgument(NTTP, NTTPType, E.
get(), Result);
5466 Converted.push_back(Result);
5493 Diag(SR.
getBegin(), diag::err_template_arg_nontype_ambig) << SR << T;
5495 Diag(SR.
getBegin(), diag::err_template_arg_must_be_expr) << SR;
5501 llvm_unreachable(
"Caller must expand template argument packs");
5524 TempParm, Converted,
5530 Params = SubstTemplateParams(Params, CurContext,
5549 llvm_unreachable(
"Should never see a NULL template argument here");
5553 if (CheckTemplateTemplateArgument(TempParm, Params, Arg))
5564 << getLangOpts().CPlusPlus11;
5568 llvm_unreachable(
"Declaration argument with template template parameter");
5570 llvm_unreachable(
"Integral argument with template template parameter");
5572 llvm_unreachable(
"Null pointer argument with template template parameter");
5575 llvm_unreachable(
"Caller must expand template argument packs");
5582 template<
typename TemplateParmDecl>
5585 const TemplateParmDecl *D,
5590 ->getTemplateParameters()
5591 ->getParam(D->getIndex()));
5598 D->getDefaultArgumentLoc(), Modules,
5609 S.
Diag(Loc, diag::err_template_arg_list_different_arity)
5624 bool UpdateArgsWithConversions,
bool *ConstraintsNotSatisfied) {
5626 if (ConstraintsNotSatisfied)
5627 *ConstraintsNotSatisfied =
false;
5639 ->getTemplateParameters();
5648 bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
5650 unsigned ArgIdx = 0, NumArgs = NewArgs.
size();
5653 ParamEnd = Params->
end();
5654 Param != ParamEnd; ) {
5658 if (*Expansions == ArgumentPack.size()) {
5661 Converted.push_back(
5663 ArgumentPack.clear();
5668 }
else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
5670 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5680 if (ArgIdx < NumArgs) {
5682 if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template,
5683 TemplateLoc, RAngleLoc,
5684 ArgumentPack.size(), Converted))
5687 bool PackExpansionIntoNonPack =
5688 NewArgs[ArgIdx].getArgument().isPackExpansion() &&
5690 if (PackExpansionIntoNonPack && (isa<TypeAliasTemplateDecl>(Template) ||
5691 isa<ConceptDecl>(Template))) {
5697 Diag(NewArgs[ArgIdx].getLocation(),
5698 diag::err_template_expansion_into_fixed_list)
5699 << (isa<ConceptDecl>(Template) ? 1 : 0)
5701 Diag((*Param)->getLocation(), diag::note_template_param_here);