31 #include "llvm/ADT/SmallBitVector.h" 32 #include "llvm/ADT/SmallString.h" 33 #include "llvm/ADT/StringExtras.h" 36 using namespace clang;
44 return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
63 assert(!FD &&
"Cannot collect constraints from function declaration yet.");
74 bool AllowFunctionTemplates,
75 bool AllowDependent) {
78 if (isa<TemplateDecl>(D)) {
79 if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(D))
97 if (Record->isInjectedClassName()) {
98 Record = cast<CXXRecordDecl>(Record->getDeclContext());
99 if (Record->getDescribedClassTemplate())
100 return Record->getDescribedClassTemplate();
103 = dyn_cast<ClassTemplateSpecializationDecl>(Record))
104 return Spec->getSpecializedTemplate();
113 if (AllowDependent && isa<UnresolvedUsingValueDecl>(D))
120 bool AllowFunctionTemplates,
121 bool AllowDependent) {
125 if (!getAsTemplateNameDecl(Orig, AllowFunctionTemplates, AllowDependent))
132 bool AllowFunctionTemplates,
133 bool AllowDependent) {
135 if (getAsTemplateNameDecl(*I, AllowFunctionTemplates, AllowDependent))
143 bool hasTemplateKeyword,
146 bool EnteringContext,
148 bool &MemberOfUnknownSpecialization) {
149 assert(getLangOpts().
CPlusPlus &&
"No template names in C!");
152 MemberOfUnknownSpecialization =
false;
175 if (LookupTemplateName(R, S, SS, ObjectType, EnteringContext,
176 MemberOfUnknownSpecialization))
181 if (R.isAmbiguous()) {
184 bool AnyFunctionTemplates =
false;
186 if (
NamedDecl *FoundTemplate = getAsTemplateNameDecl(FoundD)) {
187 if (isa<FunctionTemplateDecl>(FoundTemplate))
188 AnyFunctionTemplates =
true;
198 if (!D && !AnyFunctionTemplates) {
199 R.suppressDiagnostics();
206 FilterAcceptableTemplateNames(R);
216 unsigned ResultCount = R.end() - R.begin();
217 if (!D && ResultCount > 1) {
224 R.suppressDiagnostics();
227 D = getAsTemplateNameDecl(*R.begin());
228 assert(D &&
"unambiguous result is not a template name");
231 if (isa<UnresolvedUsingValueDecl>(D)) {
233 MemberOfUnknownSpecialization =
true;
242 hasTemplateKeyword, TD);
247 if (isa<FunctionTemplateDecl>(TD)) {
251 R.suppressDiagnostics();
253 assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
254 isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||
255 isa<BuiltinTemplateDecl>(TD));
261 TemplateResult = TemplateTy::make(Template);
269 bool MemberOfUnknownSpecialization =
false;
275 if (LookupTemplateName(R, S, SS,
QualType(),
277 MemberOfUnknownSpecialization))
280 if (R.
empty())
return false;
307 if (!SS || !SS->
isSet() || !isDependentScopeSpecifier(*SS) ||
308 computeDeclContext(*SS))
314 Diag(IILoc, diag::err_template_kw_missing)
326 bool EnteringContext,
327 bool &MemberOfUnknownSpecialization,
332 MemberOfUnknownSpecialization =
false;
334 bool IsDependent =
false;
335 if (!ObjectType.
isNull()) {
338 assert(!SS.
isSet() &&
"ObjectType and scope specifier cannot coexist");
339 LookupCtx = computeDeclContext(ObjectType);
340 IsDependent = !LookupCtx;
343 "Caller should have completed object type");
350 }
else if (SS.
isSet()) {
353 LookupCtx = computeDeclContext(SS, EnteringContext);
354 IsDependent = !LookupCtx;
357 if (LookupCtx && RequireCompleteDeclContext(SS, LookupCtx))
361 bool ObjectTypeSearchedInScope =
false;
362 bool AllowFunctionTemplatesInLookup =
true;
368 LookupQualifiedName(Found, LookupCtx);
392 LookupName(Found, S);
394 if (!ObjectType.
isNull()) {
398 AllowFunctionTemplatesInLookup =
false;
399 ObjectTypeSearchedInScope =
true;
408 if (Found.
empty() && !IsDependent) {
413 auto FilterCCC = llvm::make_unique<CorrectionCandidateCallback>();
414 FilterCCC->WantTypeSpecifiers =
false;
415 FilterCCC->WantExpressionKeywords =
false;
416 FilterCCC->WantRemainingKeywords =
false;
417 FilterCCC->WantCXXNamedCasts =
true;
420 std::move(FilterCCC), CTK_ErrorRecovery, LookupCtx)) {
422 if (
auto *ND = Corrected.getFoundDecl())
424 FilterAcceptableTemplateNames(Found);
427 }
else if (!Found.
empty()) {
429 std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
430 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
432 diagnoseTypo(Corrected, PDiag(diag::err_no_member_template_suggest)
433 << Name << LookupCtx << DroppedSpecifier
436 diagnoseTypo(Corrected, PDiag(diag::err_no_template_suggest) << Name);
446 FilterAcceptableTemplateNames(Found, AllowFunctionTemplatesInLookup);
449 MemberOfUnknownSpecialization =
true;
455 if (ExampleLookupResult && TemplateKWLoc.
isValid()) {
456 Diag(Found.
getNameLoc(), diag::err_template_kw_refers_to_non_template)
459 diag::note_template_kw_refers_to_non_template)
467 if (S && !ObjectType.
isNull() && !ObjectTypeSearchedInScope &&
468 !getLangOpts().CPlusPlus11) {
478 LookupName(FoundOuter, S);
481 FilterAcceptableTemplateNames(FoundOuter,
false);
484 if (FoundOuter.empty()) {
487 }
else if (FoundOuter.isAmbiguous() || !FoundOuter.isSingleResult() ||
489 getAsTemplateNameDecl(FoundOuter.getFoundDecl()))) {
502 diag::ext_nested_name_member_ref_lookup_ambiguous)
506 diag::note_ambig_member_ref_object_type)
508 Diag(FoundOuter.getFoundDecl()->getLocation(),
509 diag::note_ambig_member_ref_scope);
532 bool MissingTemplateKeyword =
false;
535 if (
auto *DRE = dyn_cast<DeclRefExpr>(TemplateName.
get())) {
536 NameInfo = DRE->getNameInfo();
537 SS.
Adopt(DRE->getQualifierLoc());
538 LookupKind = LookupOrdinaryName;
539 Found = DRE->getFoundDecl();
540 }
else if (
auto *ME = dyn_cast<MemberExpr>(TemplateName.
get())) {
541 NameInfo = ME->getMemberNameInfo();
542 SS.
Adopt(ME->getQualifierLoc());
543 LookupKind = LookupMemberName;
544 LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();
545 Found = ME->getMemberDecl();
546 }
else if (
auto *DSDRE =
547 dyn_cast<DependentScopeDeclRefExpr>(TemplateName.
get())) {
548 NameInfo = DSDRE->getNameInfo();
549 SS.
Adopt(DSDRE->getQualifierLoc());
550 MissingTemplateKeyword =
true;
551 }
else if (
auto *DSME =
552 dyn_cast<CXXDependentScopeMemberExpr>(TemplateName.
get())) {
553 NameInfo = DSME->getMemberNameInfo();
554 SS.
Adopt(DSME->getQualifierLoc());
555 MissingTemplateKeyword =
true;
557 llvm_unreachable(
"unexpected kind of potential template name");
562 if (MissingTemplateKeyword) {
571 TemplateCandidateFilter(
Sema &S) : S(S) {
572 WantTypeSpecifiers =
false;
573 WantExpressionKeywords =
false;
574 WantRemainingKeywords =
false;
575 WantCXXNamedCasts =
true;
577 bool ValidateCandidate(
const TypoCorrection &Candidate)
override {
586 CorrectTypo(NameInfo, LookupKind, S, &SS,
587 llvm::make_unique<TemplateCandidateFilter>(*
this),
588 CTK_ErrorRecovery, LookupCtx)) {
589 auto *ND = Corrected.getFoundDecl();
591 ND = getAsTemplateNameDecl(ND);
592 if (ND || Corrected.isKeyword()) {
594 std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
595 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
597 diagnoseTypo(Corrected,
598 PDiag(diag::err_non_template_in_member_template_id_suggest)
599 << Name << LookupCtx << DroppedSpecifier
602 diagnoseTypo(Corrected,
603 PDiag(diag::err_non_template_in_template_id_suggest)
608 diag::note_non_template_in_template_id_found);
613 Diag(NameInfo.
getLoc(), diag::err_non_template_in_template_id)
616 Diag(Found->
getLocation(), diag::note_non_template_in_template_id_found);
626 bool isAddressOfOperand,
641 bool MightBeCxx11UnevalField =
642 getLangOpts().CPlusPlus11 && isUnevaluatedContext();
647 IsEnum = dyn_cast_or_null<EnumType>(NNS->getAsType());
649 if (!MightBeCxx11UnevalField && !isAddressOfOperand && !IsEnum &&
650 isa<CXXMethodDecl>(DC) && cast<CXXMethodDecl>(DC)->isInstance()) {
651 QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType();
655 NamedDecl *FirstQualifierInScope =
nullptr;
658 Context,
nullptr, ThisType,
true,
660 FirstQualifierInScope, NameInfo, TemplateArgs);
663 return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
681 bool InstantiatedFromMember,
686 assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||
687 isa<VarDecl>(Instantiation));
689 bool IsEntityBeingDefined =
false;
690 if (
const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
691 IsEntityBeingDefined = TD->isBeingDefined();
693 if (PatternDef && !IsEntityBeingDefined) {
695 if (!hasVisibleDefinition(const_cast<NamedDecl*>(PatternDef), &SuggestedDef,
698 bool Recover = Complain && !isSFINAEContext();
700 diagnoseMissingImport(PointOfInstantiation, SuggestedDef,
707 if (!Complain || (PatternDef && PatternDef->
isInvalidDecl()))
712 if (
TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
715 Diag(PointOfInstantiation,
716 diag::err_template_instantiate_within_definition)
722 }
else if (InstantiatedFromMember) {
723 if (isa<FunctionDecl>(Instantiation)) {
724 Diag(PointOfInstantiation,
725 diag::err_explicit_instantiation_undefined_member)
728 Note = diag::note_explicit_instantiation_here;
730 assert(isa<TagDecl>(Instantiation) &&
"Must be a TagDecl!");
731 Diag(PointOfInstantiation,
732 diag::err_implicit_instantiate_member_undefined)
734 Note = diag::note_member_declared_at;
737 if (isa<FunctionDecl>(Instantiation)) {
738 Diag(PointOfInstantiation,
739 diag::err_explicit_instantiation_undefined_func_template)
741 Note = diag::note_explicit_instantiation_here;
742 }
else if (isa<TagDecl>(Instantiation)) {
743 Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
746 Note = diag::note_template_decl_here;
748 assert(isa<VarDecl>(Instantiation) &&
"Must be a VarDecl!");
749 if (isa<VarTemplateSpecializationDecl>(Instantiation)) {
750 Diag(PointOfInstantiation,
751 diag::err_explicit_instantiation_undefined_var_template)
755 Diag(PointOfInstantiation,
756 diag::err_explicit_instantiation_undefined_member)
759 Note = diag::note_explicit_instantiation_here;
782 if (getLangOpts().MicrosoftExt)
788 Diag(Loc, diag::err_template_param_shadow)
789 << cast<NamedDecl>(PrevDecl)->getDeclName();
797 if (
TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
798 D = Temp->getTemplatedDecl();
806 assert(
Kind == Template &&
807 "Only template template arguments can be pack expansions here");
808 assert(getAsTemplate().
get().containsUnexpandedParameterPack() &&
809 "Template template argument pack expansion without packs");
811 Result.EllipsisLoc = EllipsisLoc;
847 llvm_unreachable(
"Unhandled parsed template argument");
854 for (
unsigned I = 0,
Last = TemplateArgsIn.size(); I !=
Last; ++I)
874 QualType T = GetTypeFromParser(ParsedType.
get(), &TInfo);
877 assert(TInfo &&
"template argument with no location");
885 EllipsisLoc = PET.getEllipsisLoc();
886 TL = PET.getPatternLoc();
891 SS.
Adopt(ET.getQualifierLoc());
892 TL = ET.getNamedTypeLoc();
896 TemplateName Name = DTST.getTypePtr()->getTemplateName();
902 DTST.getTemplateNameLoc());
904 Result = Result.getTemplatePackExpansion(EllipsisLoc);
914 ParsedType.
get().getAsOpaquePtr(),
932 unsigned Depth,
unsigned Position,
936 "Template type parameter not in template parameter scope!");
942 bool IsParameterPack = EllipsisLoc.
isValid();
945 KeyLoc, Loc,
Depth, Position, ParamName,
946 Typename, IsParameterPack);
954 IdResolver.AddDecl(Param);
960 if (DefaultArg && IsParameterPack) {
961 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
962 DefaultArg =
nullptr;
968 GetTypeFromParser(DefaultArg, &DefaultTInfo);
970 assert(DefaultTInfo &&
"expected source information for type");
973 if (DiagnoseUnexpandedParameterPack(Loc, DefaultTInfo,
974 UPPC_DefaultArgument))
978 if (CheckTemplateArgument(Param, DefaultTInfo)) {
1002 TSI = SubstAutoTypeSourceInfo(TSI, Context.
DependentTy);
1005 return CheckNonTypeTemplateParameterType(TSI->
getType(), Loc);
1013 Diag(Loc, diag::err_variably_modified_nontype_template_param)
1051 Diag(Loc, diag::err_template_nontype_parm_bad_type)
1065 auto CheckValidDeclSpecifiers = [
this, &D] {
1079 Diag(Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
1116 CheckValidDeclSpecifiers();
1120 diag::warn_cxx14_compat_template_nontype_parm_auto_type)
1125 "Non-type template parameter not in template parameter scope!");
1126 bool Invalid =
false;
1151 IdResolver.AddDecl(Param);
1157 if (Default && IsParameterPack) {
1158 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1165 if (DiagnoseUnexpandedParameterPack(Default, UPPC_DefaultArgument))
1170 CheckTemplateArgument(Param, Param->
getType(), Default, Converted);
1175 Default = DefaultRes.
get();
1197 "Template template parameter not in template parameter scope!");
1200 bool IsParameterPack = EllipsisLoc.
isValid();
1204 Depth, Position, IsParameterPack,
1214 IdResolver.AddDecl(Param);
1217 if (Params->
size() == 0) {
1226 if (IsParameterPack && !Default.
isInvalid()) {
1227 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1242 Diag(DefaultArg.
getLocation(), diag::err_template_arg_not_valid_template)
1248 if (DiagnoseUnexpandedParameterPack(DefaultArg.
getLocation(),
1250 UPPC_DefaultArgument))
1269 Expr *RequiresClause) {
1271 Diag(ExportLoc, diag::warn_template_export_unsupported);
1274 Context, TemplateLoc, LAngleLoc,
1275 llvm::makeArrayRef(Params.data(), Params.size()),
1276 RAngleLoc, RequiresClause);
1292 assert(TemplateParams && TemplateParams->
size() > 0 &&
1293 "No template parameters");
1294 assert(TUK != TUK_Reference &&
"Can only declare or define class templates");
1295 bool Invalid =
false;
1298 if (CheckTemplateDeclScope(S, TemplateParams))
1302 assert(Kind !=
TTK_Enum &&
"can't build template of enumerated type");
1306 Diag(KWLoc, diag::err_template_unnamed_class);
1315 (SS.
isEmpty() && TUK == TUK_Friend)
1316 ? LookupTagName : LookupOrdinaryName,
1317 forRedeclarationInCurContext());
1319 SemanticContext = computeDeclContext(SS,
true);
1320 if (!SemanticContext) {
1324 Diag(NameLoc, TUK == TUK_Friend
1325 ? diag::warn_template_qualified_friend_ignored
1326 : diag::err_template_qualified_declarator_no_match)
1328 return TUK != TUK_Friend;
1331 if (RequireCompleteDeclContext(SS, SemanticContext))
1339 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
1341 }
else if (TUK != TUK_Friend && TUK != TUK_Reference)
1342 diagnoseQualifiedDeclaration(SS, SemanticContext, Name, NameLoc,
false);
1344 LookupQualifiedName(
Previous, SemanticContext);
1346 SemanticContext = CurContext;
1352 if (TUK != TUK_Friend &&
1353 DiagnoseClassNameShadow(SemanticContext,
1365 PrevDecl = (*
Previous.begin())->getUnderlyingDecl();
1369 DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
1377 dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
1382 if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) &&
1383 cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
1386 = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
1387 if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
1389 = cast<ClassTemplateSpecializationDecl>(PrevDecl)
1390 ->getSpecializedTemplate();
1394 if (TUK == TUK_Friend) {
1413 PrevDecl = PrevClassTemplate =
nullptr;
1414 SemanticContext = OutermostContext;
1418 Previous.clear(LookupOrdinaryName);
1422 LookupQualifiedName(
Previous, LookupContext);
1428 PrevDecl = (*
Previous.begin())->getUnderlyingDecl();
1431 }
else if (PrevDecl &&
1432 !isDeclInScope(
Previous.getRepresentativeDecl(), SemanticContext,
1434 PrevDecl = PrevClassTemplate =
nullptr;
1436 if (
auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
1437 PrevDecl ?
Previous.getRepresentativeDecl() :
nullptr)) {
1439 !(PrevClassTemplate &&
1442 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
1443 Diag(Shadow->getTargetDecl()->getLocation(),
1444 diag::note_using_decl_target);
1445 Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
1447 PrevDecl = PrevClassTemplate =
nullptr;
1454 if (PrevClassTemplate) {
1458 if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1459 !TemplateParameterListsAreEqual(TemplateParams,
1467 const bool RedeclACMismatch = [&] {
1468 if (!(CurAC || PrevAC))
1470 if (CurAC && PrevAC) {
1471 llvm::FoldingSetNodeID CurACInfo, PrevACInfo;
1472 CurAC->
Profile(CurACInfo, Context,
true);
1473 PrevAC->
Profile(PrevACInfo, Context,
true);
1474 if (CurACInfo == PrevACInfo)
1480 if (RedeclACMismatch) {
1482 diag::err_template_different_associated_constraints);
1484 diag::note_template_prev_declaration)
1495 if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind,
1496 TUK == TUK_Definition, KWLoc, Name)) {
1497 Diag(KWLoc, diag::err_use_with_wrong_tag)
1505 if (TUK == TUK_Definition) {
1510 if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
1513 auto *Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();
1514 assert(Tmpl &&
"original definition of a class template is not a " 1516 makeMergedDefinitionVisible(Hidden);
1517 makeMergedDefinitionVisible(Tmpl);
1519 Diag(NameLoc, diag::err_redefinition) << Name;
1520 Diag(Def->getLocation(), diag::note_previous_definition);
1527 }
else if (PrevDecl) {
1533 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
1542 if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1543 CheckTemplateParameterList(
1548 (SS.
isSet() && SemanticContext && SemanticContext->
isRecord() &&
1550 ? TPC_ClassTemplateMember
1551 : TUK == TUK_Friend ? TPC_FriendClassTemplate : TPC_ClassTemplate,
1558 if (!SS.
isInvalid() && !Invalid && !PrevClassTemplate) {
1559 Diag(NameLoc, TUK == TUK_Friend ? diag::err_friend_decl_does_not_match
1560 : diag::err_member_decl_does_not_match)
1561 << Name << SemanticContext <<
true << SS.
getRange();
1571 bool ShouldAddRedecl
1572 = !(TUK == TUK_Friend && CurContext->isDependentContext());
1576 PrevClassTemplate && ShouldAddRedecl ?
1580 if (NumOuterTemplateParamLists > 0)
1582 Context, llvm::makeArrayRef(OuterTemplateParamLists,
1583 NumOuterTemplateParamLists));
1587 if (TUK == TUK_Definition && (!SkipBody || !SkipBody->
ShouldSkip)) {
1588 AddAlignmentAttributesForRecord(NewClass);
1589 AddMsStructLayoutForRecord(NewClass);
1594 Expr *
const ACtoAttach =
1595 PrevClassTemplate && ShouldAddRedecl ? nullptr : CurAC;
1600 NewClass, ACtoAttach);
1602 if (ShouldAddRedecl)
1607 if (ModulePrivateLoc.
isValid())
1613 assert(T->
isDependentType() &&
"Class template type is not dependent?");
1618 if (PrevClassTemplate &&
1624 SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS);
1630 if (TUK == TUK_Definition && (!SkipBody || !SkipBody->
ShouldSkip))
1633 ProcessDeclAttributeList(S, NewClass, Attr);
1635 if (PrevClassTemplate)
1638 AddPushedVisibilityAttribute(NewClass);
1640 if (TUK != TUK_Friend) {
1645 PushOnScopeChains(NewTemplate, Outer);
1655 if (!CurContext->isDependentContext()) {
1658 if (
Scope *EnclosingScope = getScopeForDeclContext(S, DC))
1659 PushOnScopeChains(NewTemplate, EnclosingScope,
1664 Context, CurContext, NewClass->
getLocation(), NewTemplate, FriendLoc);
1666 CurContext->addDecl(Friend);
1669 if (PrevClassTemplate)
1670 CheckRedeclarationModuleOwnership(NewTemplate, PrevClassTemplate);
1677 ActOnDocumentableDecl(NewTemplate);
1688 class ExtractTypeForDeductionGuide
1692 ExtractTypeForDeductionGuide(
Sema &SemaRef) : Base(SemaRef) {}
1697 return TransformType(
1705 struct ConvertConstructorToDeductionGuideTransform {
1706 ConvertConstructorToDeductionGuideTransform(
Sema &S,
1708 : SemaRef(S), Template(Template) {}
1742 AllParams.reserve(TemplateParams->
size() + InnerParams->
size());
1743 AllParams.insert(AllParams.begin(),
1744 TemplateParams->
begin(), TemplateParams->
end());
1745 SubstArgs.reserve(InnerParams->
size());
1753 NamedDecl *NewParam = transformTemplateParameter(Param, Args);
1756 AllParams.push_back(NewParam);
1761 SemaRef.
Context, InnerParams->getTemplateLoc(),
1762 InnerParams->getLAngleLoc(), AllParams, InnerParams->getRAngleLoc(),
1772 Args.addOuterRetainedLevel();
1777 assert(FPTL &&
"no prototype for constructor declaration");
1784 QualType NewType = transformFunctionProtoType(TLB, FPTL, Params, Args);
1789 return buildDeductionGuide(TemplateParams, CD->
isExplicit(), NewTInfo,
1802 DeductionGuideName, EPI);
1810 for (
auto T : ParamTypes) {
1812 SemaRef.
Context, DC, Loc, Loc,
nullptr, T,
1815 FPTL.
setParam(Params.size(), NewParam);
1816 Params.push_back(NewParam);
1829 if (
auto *TTP = dyn_cast<TemplateTypeParmDecl>(TemplateParam)) {
1833 SemaRef.
Context, DC, TTP->getBeginLoc(), TTP->getLocation(),
1834 0, Depth1IndexAdjustment + TTP->getIndex(),
1835 TTP->getIdentifier(), TTP->wasDeclaredWithTypename(),
1836 TTP->isParameterPack());
1837 if (TTP->hasDefaultArgument()) {
1839 SemaRef.
SubstType(TTP->getDefaultArgumentInfo(), Args,
1840 TTP->getDefaultArgumentLoc(), TTP->getDeclName());
1841 if (InstantiatedDefaultArg)
1842 NewTTP->setDefaultArgument(InstantiatedDefaultArg);
1849 if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TemplateParam))
1850 return transformTemplateParameterImpl(TTP, Args);
1852 return transformTemplateParameterImpl(
1853 cast<NonTypeTemplateParmDecl>(TemplateParam), Args);
1855 template<
typename TemplateParmDecl>
1857 transformTemplateParameterImpl(TemplateParmDecl *OldParam,
1862 cast_or_null<TemplateParmDecl>(SemaRef.
SubstDecl(OldParam, DC, Args));
1863 assert(NewParam->getDepth() == 0 &&
"unexpected template param depth");
1864 NewParam->setPosition(NewParam->getPosition() + Depth1IndexAdjustment);
1877 ParmVarDecl *NewParam = transformFunctionTypeParam(OldParam, Args);
1880 ParamTypes.push_back(NewParam->
getType());
1881 Params.push_back(NewParam);
1903 ReturnType, ParamTypes, TL.
getBeginLoc(), DeductionGuideName, EPI);
1913 for (
unsigned I = 0, E = NewTL.
getNumParams(); I != E; ++I)
1928 SemaRef.
SubstType(PackTL.getPatternLoc(), Args,
1930 if (!NewDI)
return nullptr;
1933 PackTL.getTypePtr()->getNumExpansions());
1944 NewDI = ExtractTypeForDeductionGuide(SemaRef).transform(NewDI);
1980 Name, TInfo->
getType(), TInfo, LocEnd);
1982 Guide->setParams(Params);
1984 for (
auto *Param : Params)
1985 Param->setDeclContext(Guide);
1988 SemaRef.
Context, DC, Loc, DeductionGuideName, TemplateParams, Guide);
1989 GuideTemplate->setImplicit();
1990 Guide->setDescribedFunctionTemplate(GuideTemplate);
1992 if (isa<CXXRecordDecl>(DC)) {
1998 return GuideTemplate;
2009 ConvertConstructorToDeductionGuideTransform Transform(
2010 *
this, cast<ClassTemplateDecl>(Template));
2011 if (!isCompleteType(Loc, Transform.DeducedType))
2016 auto Existing = DC->
lookup(Transform.DeductionGuideName);
2017 for (
auto *D : Existing)
2018 if (D->isImplicit())
2029 if (BuildingDeductionGuides.
isInvalid())
2036 bool AddedAny =
false;
2037 for (
NamedDecl *D : LookupConstructors(Transform.Primary)) {
2038 D = D->getUnderlyingDecl();
2039 if (D->isInvalidDecl() || D->isImplicit())
2041 D = cast<NamedDecl>(D->getCanonicalDecl());
2045 dyn_cast_or_null<CXXConstructorDecl>(FTD ? FTD->getTemplatedDecl() : D);
2048 if (!CD || (!FTD && CD->isFunctionTemplateSpecialization()))
2051 Transform.transformConstructor(FTD, CD);
2060 Transform.buildSimpleDeductionGuide(None);
2064 cast<CXXDeductionGuideDecl>(
2065 cast<FunctionTemplateDecl>(
2066 Transform.buildSimpleDeductionGuide(Transform.DeducedType))
2067 ->getTemplatedDecl())
2068 ->setIsCopyDeductionCandidate();
2096 diag::warn_cxx98_compat_template_parameter_default_in_function_template
2097 : diag::ext_template_parameter_default_in_function_template)
2106 S.
Diag(ParamLoc, diag::err_template_parameter_default_template_member)
2115 S.
Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
2124 llvm_unreachable(
"Invalid TemplateParamListContext!");
2137 for (
unsigned I = 0, N = Params->
size(); I != N; ++I) {
2140 if (!NTTP->isParameterPack() &&
2142 NTTP->getTypeSourceInfo(),
2150 = dyn_cast<TemplateTemplateParmDecl>(P))
2190 bool Invalid =
false;
2198 bool SawDefaultArgument =
false;
2204 OldParam = OldParams->
begin();
2206 bool RemoveDefaultArguments =
false;
2208 NewParamEnd = NewParams->
end();
2209 NewParam != NewParamEnd; ++NewParam) {
2211 bool RedundantDefaultArg =
false;
2216 bool MissingDefaultArg =
false;
2219 bool SawParameterPack =
false;
2222 = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
2224 if (NewTypeParm->hasDefaultArgument() &&
2226 NewTypeParm->getLocation(),
2227 NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
2229 NewTypeParm->removeDefaultArgument();
2233 = OldParams? cast<TemplateTypeParmDecl>(*OldParam) :
nullptr;
2234 if (NewTypeParm->isParameterPack()) {
2235 assert(!NewTypeParm->hasDefaultArgument() &&
2236 "Parameter packs can't have a default argument!");
2237 SawParameterPack =
true;
2239 NewTypeParm->hasDefaultArgument() &&
2242 NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
2243 SawDefaultArgument =
true;
2244 RedundantDefaultArg =
true;
2245 PreviousDefaultArgLoc = NewDefaultLoc;
2249 NewTypeParm->setInheritedDefaultArgument(Context, OldTypeParm);
2251 }
else if (NewTypeParm->hasDefaultArgument()) {
2252 SawDefaultArgument =
true;
2253 PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
2254 }
else if (SawDefaultArgument)
2255 MissingDefaultArg =
true;
2257 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
2259 if (!NewNonTypeParm->isParameterPack() &&
2260 DiagnoseUnexpandedParameterPack(NewNonTypeParm->getLocation(),
2261 NewNonTypeParm->getTypeSourceInfo(),
2262 UPPC_NonTypeTemplateParameterType)) {
2268 if (NewNonTypeParm->hasDefaultArgument() &&
2270 NewNonTypeParm->getLocation(),
2271 NewNonTypeParm->getDefaultArgument()->getSourceRange())) {
2272 NewNonTypeParm->removeDefaultArgument();
2277 = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) :
nullptr;
2278 if (NewNonTypeParm->isParameterPack()) {
2279 assert(!NewNonTypeParm->hasDefaultArgument() &&
2280 "Parameter packs can't have a default argument!");
2281 if (!NewNonTypeParm->isPackExpansion())
2282 SawParameterPack =
true;
2284 NewNonTypeParm->hasDefaultArgument() &&
2287 NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
2288 SawDefaultArgument =
true;
2289 RedundantDefaultArg =
true;
2290 PreviousDefaultArgLoc = NewDefaultLoc;
2294 NewNonTypeParm->setInheritedDefaultArgument(Context, OldNonTypeParm);
2296 }
else if (NewNonTypeParm->hasDefaultArgument()) {
2297 SawDefaultArgument =
true;
2298 PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
2299 }
else if (SawDefaultArgument)
2300 MissingDefaultArg =
true;
2303 = cast<TemplateTemplateParmDecl>(*NewParam);
2320 = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) :
nullptr;
2323 "Parameter packs can't have a default argument!");
2325 SawParameterPack =
true;
2326 }
else if (OldTemplateParm &&
2332 SawDefaultArgument =
true;
2333 RedundantDefaultArg =
true;
2334 PreviousDefaultArgLoc = NewDefaultLoc;
2339 PreviousDefaultArgLoc
2342 SawDefaultArgument =
true;
2343 PreviousDefaultArgLoc
2345 }
else if (SawDefaultArgument)
2346 MissingDefaultArg =
true;
2352 if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
2353 (TPC == TPC_ClassTemplate || TPC == TPC_VarTemplate ||
2354 TPC == TPC_TypeAliasTemplate)) {
2355 Diag((*NewParam)->getLocation(),
2356 diag::err_template_param_pack_must_be_last_template_parameter);
2360 if (RedundantDefaultArg) {
2364 Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
2365 Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
2367 }
else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) {
2373 Diag((*NewParam)->getLocation(),
2374 diag::err_template_param_default_arg_missing);
2375 Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
2377 RemoveDefaultArguments =
true;
2388 if (RemoveDefaultArguments) {
2390 NewParamEnd = NewParams->
end();
2391 NewParam != NewParamEnd; ++NewParam) {
2393 TTP->removeDefaultArgument();
2395 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
2396 NTTP->removeDefaultArgument();
2398 cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
2418 bool IgnoreNonTypeDependent;
2423 DependencyChecker(
unsigned Depth,
bool IgnoreNonTypeDependent)
2424 :
Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
2428 : IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(
false) {
2431 Depth = PD->getDepth();
2433 dyn_cast<NonTypeTemplateParmDecl>(ND)) {
2434 Depth = PD->getDepth();
2436 Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
2441 if (ParmDepth >= Depth) {
2449 bool TraverseStmt(
Stmt *S, DataRecursionQueue *Q =
nullptr) {
2454 if (
auto *E = dyn_cast_or_null<Expr>(S))
2455 if (IgnoreNonTypeDependent && !E->isTypeDependent())
2457 return super::TraverseStmt(S, Q);
2460 bool TraverseTypeLoc(
TypeLoc TL) {
2461 if (IgnoreNonTypeDependent && !TL.
isNull() &&
2464 return super::TraverseTypeLoc(TL);
2473 return IgnoreNonTypeDependent || !Matches(T->
getDepth());
2479 if (Matches(PD->getDepth()))
2481 return super::TraverseTemplateName(N);
2486 dyn_cast<NonTypeTemplateParmDecl>(E->
getDecl()))
2487 if (Matches(PD->getDepth(), E->
getExprLoc()))
2489 return super::VisitDeclRefExpr(E);
2511 DependencyChecker Checker(Params,
false);
2512 Checker.TraverseType(T);
2513 return Checker.Match;
2523 if (
const Type *CurType = NNS->getAsType()) {
2529 NNSLoc = NNSLoc.getPrefix();
2572 bool &IsMemberSpecialization,
bool &Invalid) {
2573 IsMemberSpecialization =
false;
2583 = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS,
true)))
2595 NestedTypes.push_back(T);
2601 = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
2602 if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
2604 ExplicitSpecLoc = Spec->getLocation();
2607 }
else if (Record->getTemplateSpecializationKind()
2609 ExplicitSpecLoc = Record->getLocation();
2622 if (
TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2623 if (
TypeDecl *
Parent = dyn_cast<TypeDecl>(Template->getDeclContext()))
2668 std::reverse(NestedTypes.begin(), NestedTypes.end());
2676 bool SawNonEmptyTemplateParameterList =
false;
2678 auto CheckExplicitSpecialization = [&](
SourceRange Range,
bool Recovery) {
2679 if (SawNonEmptyTemplateParameterList) {
2680 Diag(DeclLoc, diag::err_specialize_member_of_template)
2681 << !Recovery << Range;
2683 IsMemberSpecialization =
false;
2690 auto DiagnoseMissingExplicitSpecialization = [&] (
SourceRange Range) {
2692 if (CheckExplicitSpecialization(Range,
true))
2697 if (!ParamLists.empty())
2698 ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
2700 ExpectedTemplateLoc = DeclStartLoc;
2702 Diag(DeclLoc, diag::err_template_spec_needs_header)
2709 for (
unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
2711 T = NestedTypes[TypeIdx];
2714 bool NeedEmptyTemplateHeader =
false;
2717 bool NeedNonemptyTemplateHeader =
false;
2730 = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) {
2731 ExpectedTemplateParams = Partial->getTemplateParameters();
2732 NeedNonemptyTemplateHeader =
true;
2733 }
else if (Record->isDependentType()) {
2734 if (Record->getDescribedClassTemplate()) {
2735 ExpectedTemplateParams = Record->getDescribedClassTemplate()
2736 ->getTemplateParameters();
2737 NeedNonemptyTemplateHeader =
true;
2740 = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
2746 NeedEmptyTemplateHeader =
true;
2749 }
else if (Record->getTemplateSpecializationKind()) {
2750 if (Record->getTemplateSpecializationKind()
2752 TypeIdx == NumTypes - 1)
2753 IsMemberSpecialization =
true;
2759 if (
TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2760 ExpectedTemplateParams = Template->getTemplateParameters();
2761 NeedNonemptyTemplateHeader =
true;
2766 NeedNonemptyTemplateHeader =
false;
2776 if (ParamIdx < ParamLists.size()) {
2777 if (ParamLists[ParamIdx]->size() == 0) {
2778 if (CheckExplicitSpecialization(ParamLists[ParamIdx]->
getSourceRange(),
2782 SawNonEmptyTemplateParameterList =
true;
2785 if (NeedEmptyTemplateHeader) {
2788 if (TypeIdx == NumTypes - 1)
2789 IsMemberSpecialization =
true;
2791 if (ParamIdx < ParamLists.size()) {
2792 if (ParamLists[ParamIdx]->size() > 0) {
2794 Diag(ParamLists[ParamIdx]->getTemplateLoc(),
2795 diag::err_template_param_list_matches_nontemplate)
2797 <<
SourceRange(ParamLists[ParamIdx]->getLAngleLoc(),
2798 ParamLists[ParamIdx]->getRAngleLoc())
2810 if (DiagnoseMissingExplicitSpecialization(
2817 if (NeedNonemptyTemplateHeader) {
2823 if (ParamIdx < ParamLists.size() &&
2825 ExpectedTemplateParams =
nullptr;
2830 if (ParamIdx < ParamLists.size()) {
2832 if (ExpectedTemplateParams &&
2833 !TemplateParameterListsAreEqual(ParamLists[ParamIdx],
2834 ExpectedTemplateParams,
2835 true, TPL_TemplateMatch))
2839 CheckTemplateParameterList(ParamLists[ParamIdx],
nullptr,
2840 TPC_ClassTemplateMember))
2847 Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
2858 if (ParamIdx >= ParamLists.size()) {
2859 if (TemplateId && !IsFriend) {
2875 if (ParamIdx < ParamLists.size() - 1) {
2876 bool HasAnyExplicitSpecHeader =
false;
2877 bool AllExplicitSpecHeaders =
true;
2878 for (
unsigned I = ParamIdx, E = ParamLists.size() - 1; I != E; ++I) {
2879 if (ParamLists[I]->size() == 0)
2880 HasAnyExplicitSpecHeader =
true;
2882 AllExplicitSpecHeaders =
false;
2885 Diag(ParamLists[ParamIdx]->getTemplateLoc(),
2886 AllExplicitSpecHeaders ? diag::warn_template_spec_extra_headers
2887 : diag::err_template_spec_extra_headers)
2888 <<
SourceRange(ParamLists[ParamIdx]->getTemplateLoc(),
2889 ParamLists[ParamLists.size() - 2]->getRAngleLoc());
2894 if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader)
2895 Diag(ExplicitSpecLoc,
2896 diag::note_explicit_template_spec_does_not_need_header)
2897 << NestedTypes.back();
2902 if (!AllExplicitSpecHeaders)
2913 if (ParamLists.back()->size() == 0 &&
2914 CheckExplicitSpecialization(ParamLists[ParamIdx]->
getSourceRange(),
2920 return ParamLists.back();
2925 Diag(Template->getLocation(), diag::note_template_declared_here)
2926 << (isa<FunctionTemplateDecl>(Template)
2928 : isa<ClassTemplateDecl>(Template)
2930 : isa<VarTemplateDecl>(Template)
2932 : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
2933 << Template->getDeclName();
2941 Diag((*I)->getLocation(), diag::note_template_declared_here)
2942 << 0 << (*I)->getDeclName();
2961 if (!Converted[1].getAsType()->isIntegralType(Context)) {
2962 SemaRef.
Diag(TemplateArgs[1].getLocation(),
2963 diag::err_integer_sequence_integral_element_type);
2972 SemaRef.
Diag(TemplateArgs[2].getLocation(),
2973 diag::err_integer_sequence_negative_length);
2981 SyntheticTemplateArgs.
addArgument(TemplateArgs[1]);
2983 for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
2987 TA, ArgTy, TemplateArgs[2].getLocation()));
2992 TemplateLoc, SyntheticTemplateArgs);
2999 assert(Converted.size() == 2 &&
3000 "__type_pack_element should be given an index and a parameter pack");
3004 llvm::APSInt Index = IndexArg.getAsIntegral();
3005 assert(Index >= 0 &&
"the index used with __type_pack_element should be of " 3006 "type std::size_t, and hence be non-negative");
3007 if (Index >= Ts.pack_size()) {
3008 SemaRef.
Diag(TemplateArgs[0].getLocation(),
3009 diag::err_type_pack_element_out_of_bounds);
3014 auto Nth = std::next(Ts.pack_begin(), Index.getExtValue());
3015 return Nth->getAsType();
3017 llvm_unreachable(
"unexpected BuiltinTemplateDecl!");
3022 return AliasTemplate->
getName().equals(
"enable_if_t");
3034 if (BinOp->getOpcode() == BO_LAnd) {
3042 Terms.push_back(Clause);
3051 if (!BinOp)
return Cond;
3053 if (BinOp->getOpcode() != BO_LOr)
return Cond;
3056 Expr *LHS = BinOp->getLHS();
3058 if (!InnerBinOp)
return Cond;
3060 if (InnerBinOp->getOpcode() != BO_EQ ||
3061 !isa<IntegerLiteral>(InnerBinOp->getRHS()))
3071 if (MacroName ==
"CONCEPT_REQUIRES" || MacroName ==
"CONCEPT_REQUIRES_")
3072 return BinOp->getRHS();
3082 class FailedBooleanConditionPrinterHelper :
public PrinterHelper {
3087 bool handledStmt(
Stmt *E, raw_ostream &OS)
override {
3089 if (DR && DR->getQualifier()) {
3096 if (
const auto *IV = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
3111 std::pair<Expr *, std::string>
3120 Expr *FailedCond =
nullptr;
3121 for (
Expr *Term : Terms) {
3125 if (isa<CXXBoolLiteralExpr>(TermAsWritten) ||
3126 isa<IntegerLiteral>(TermAsWritten))
3135 if (Term->EvaluateAsBooleanCondition(Succeeded, Context) &&
3137 FailedCond = TermAsWritten;
3144 std::string Description;
3146 llvm::raw_string_ostream Out(Description);
3149 FailedBooleanConditionPrinterHelper Helper(Policy);
3150 FailedCond->
printPretty(Out, &Helper, Policy, 0,
"\n",
nullptr);
3152 return { FailedCond, Description };
3171 if (!Template || isa<FunctionTemplateDecl>(Template) ||
3172 isa<VarTemplateDecl>(Template)) {
3178 Diag(TemplateLoc, diag::err_template_id_not_a_type)
3180 NoteAllFoundTemplates(Name);
3187 if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
3193 bool InstantiationDependent =
false;
3195 dyn_cast<TypeAliasTemplateDecl>(Template)) {
3207 unsigned Depth = AliasTemplate->getTemplateParameters()->getDepth();
3208 for (
unsigned I = 0; I <
Depth; ++I)
3217 TemplateArgLists, AliasTemplate->getLocation(),
3218 AliasTemplate->getDeclName());
3219 if (CanonType.
isNull()) {
3224 if (
auto DeductionInfo = isSFINAEContext()) {
3225 if (*DeductionInfo &&
3226 (*DeductionInfo)->hasSFINAEDiagnostic() &&
3227 (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
3228 diag::err_typename_nested_not_found_enable_if &&
3229 TemplateArgs[0].getArgument().getKind()
3232 std::string FailedDescription;
3233 std::tie(FailedCond, FailedDescription) =
3234 findFailedBooleanCondition(TemplateArgs[0].getSourceExpression());
3239 (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);
3243 (*DeductionInfo)->addSFINAEDiagnostic(
3245 PDiag(diag::err_typename_nested_not_found_requirement)
3246 << FailedDescription
3256 TemplateArgs, InstantiationDependent)) {
3272 if (isa<ClassTemplateDecl>(Template)) {
3275 if (Ctx->isFileContext())
break;
3279 if (!Record)
continue;
3283 if (!isa<ClassTemplatePartialSpecializationDecl>(Record) &&
3290 QualType Injected = cast<InjectedClassNameType>(ICNT)
3291 ->getInjectedSpecializationType();
3304 = dyn_cast<ClassTemplateDecl>(Template)) {
3307 void *InsertPos =
nullptr;
3309 = ClassTemplate->findSpecialization(Converted, InsertPos);
3315 Context, ClassTemplate->getTemplatedDecl()->getTagKind(),
3316 ClassTemplate->getDeclContext(),
3317 ClassTemplate->getTemplatedDecl()->getBeginLoc(),
3318 ClassTemplate->getLocation(), ClassTemplate, Converted,
nullptr);
3319 ClassTemplate->AddSpecialization(Decl, InsertPos);
3320 if (ClassTemplate->isOutOfLine())
3327 InstantiateAttrsForDecl(TemplateArgLists, ClassTemplate->getTemplatedDecl(),
3332 (void)DiagnoseUseOfDecl(Decl, TemplateLoc);
3335 assert(isa<RecordType>(CanonType) &&
3336 "type of non-dependent specialization is not a RecordType");
3337 }
else if (
auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
3355 bool IsCtorOrDtorName,
bool IsClassName) {
3359 if (!IsCtorOrDtorName && !IsClassName && SS.
isSet()) {
3360 DeclContext *LookupCtx = computeDeclContext(SS,
false);
3368 if (!LookupCtx && isDependentScopeSpecifier(SS)) {
3375 return ActOnTypenameType(
nullptr,
SourceLocation(), SS, TemplateKWLoc,
3376 TemplateD, TemplateII, TemplateIILoc, LAngleLoc,
3377 TemplateArgsIn, RAngleLoc);
3384 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
3385 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
3388 ? diag::err_out_of_line_qualified_id_type_names_constructor
3389 : diag::ext_out_of_line_qualified_id_type_names_constructor)
3399 translateTemplateArguments(TemplateArgsIn, TemplateArgs);
3404 DTN->getQualifier(),
3405 DTN->getIdentifier(),
3417 for (
unsigned I = 0, N = SpecTL.
getNumArgs(); I != N; ++I)
3422 QualType Result = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
3423 if (Result.isNull())
3434 for (
unsigned i = 0, e = SpecTL.
getNumArgs(); i != e; ++i)
3465 translateTemplateArguments(TemplateArgsIn, TemplateArgs);
3474 DTN->getQualifier(),
3475 DTN->getIdentifier(),
3488 for (
unsigned I = 0, N = SpecTL.
getNumArgs(); I != N; ++I)
3499 Diag(TemplateLoc, diag::err_tag_reference_non_tag)
3500 << TAT << NTK_TypeAliasTemplate << TagKind;
3501 Diag(TAT->getLocation(), diag::note_declared_at);
3504 QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
3505 if (Result.isNull())
3513 assert(Id &&
"templated class must have an identifier");
3515 if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition,
3517 Diag(TagLoc, diag::err_use_with_wrong_tag)
3532 for (
unsigned i = 0, e = SpecTL.
getNumArgs(); i != e; ++i)
3541 return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
3581 dyn_cast_or_null<TemplateTemplateParmDecl>(
3585 llvm_unreachable(
"unexpected kind of template argument");
3590 if (Params->
size() != Args.size())
3595 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
3622 return TemplateArgs;
3625 template<
typename PartialSpecDecl>
3627 if (Partial->getDeclContext()->isDependentContext())
3636 auto *Template = Partial->getSpecializedTemplate();
3637 S.
Diag(Partial->getLocation(),
3638 diag::ext_partial_spec_not_more_specialized_than_primary)
3639 << isa<VarTemplateDecl>(Template);
3641 if (Info.hasSFINAEDiagnostic()) {
3644 Info.takeSFINAEDiagnostic(Diag);
3648 diag::note_partial_spec_not_more_specialized_than_primary)
3652 S.
Diag(Template->getLocation(), diag::note_template_decl_here);
3657 const llvm::SmallBitVector &DeducibleParams) {
3658 for (
unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
3659 if (!DeducibleParams[I]) {
3672 template<
typename PartialSpecDecl>
3674 PartialSpecDecl *Partial) {
3687 auto *TemplateParams = Partial->getTemplateParameters();
3688 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
3690 TemplateParams->getDepth(), DeducibleParams);
3692 if (!DeducibleParams.all()) {
3693 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
3694 S.
Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
3695 << isa<VarTemplatePartialSpecializationDecl>(Partial)
3696 << (NumNonDeducible > 1)
3698 Partial->getTemplateArgsAsWritten()->RAngleLoc);
3719 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
3720 MarkDeducedTemplateParameters(TD, DeducibleParams);
3721 for (
unsigned I = 0; I != TemplateParams->size(); ++I) {
3723 auto *Param = TemplateParams->getParam(I);
3725 DeducibleParams[I] =
true;
3728 if (!DeducibleParams.all()) {
3729 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
3730 Diag(TD->
getLocation(), diag::err_deduction_guide_template_not_deducible)
3731 << (NumNonDeducible > 1);
3742 "Variable template specialization is declared with a template it.");
3759 FnTemplate = *OTS->begin();
3766 << IsPartialSpecialization;
3770 for (
unsigned I = 0, N = TemplateArgs.
size(); I != N; ++I)
3771 if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
3772 UPPC_PartialSpecialization))
3778 if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
3784 if (IsPartialSpecialization) {
3785 if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, VarTemplate,
3786 TemplateArgs.
size(), Converted))
3791 bool InstantiationDependent;
3795 InstantiationDependent)) {
3796 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
3798 IsPartialSpecialization =
false;
3807 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
3809 << (SC !=
SC_Extern && !CurContext->isRecord())
3817 void *InsertPos =
nullptr;
3820 if (IsPartialSpecialization)
3832 IsPartialSpecialization))
3840 Specialization = PrevDecl;
3843 }
else if (IsPartialSpecialization) {
3846 cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
3850 TemplateNameLoc, TemplateParams, VarTemplate, DI->
getType(), DI, SC,
3851 Converted, TemplateArgs);
3854 VarTemplate->AddPartialSpecialization(Partial, InsertPos);
3855 Specialization = Partial;
3862 CheckTemplatePartialSpecialization(Partial);
3867 Context, VarTemplate->
getDeclContext(), TemplateKWLoc, TemplateNameLoc,
3868 VarTemplate, DI->
getType(), DI, SC, Converted);
3872 VarTemplate->AddSpecialization(Specialization, InsertPos);
3893 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
3897 diag::note_instantiation_required_here)
3910 CurContext->addDecl(Specialization);
3918 LookupResult PrevSpec(*
this, GetNameForDeclarator(D), LookupOrdinaryName,
3919 forRedeclarationInCurContext());
3934 return Specialization;
3940 struct PartialSpecMatchResult {
3950 assert(Template &&
"A variable template id without template?");
3954 if (CheckTemplateArgumentList(
3955 Template, TemplateNameLoc,
3956 const_cast<TemplateArgumentListInfo &>(TemplateArgs),
false,
3962 void *InsertPos =
nullptr;
3964 Converted, InsertPos)) {
3965 checkSpecializationVisibility(TemplateNameLoc, Spec);
3978 bool AmbiguousPartialSpec =
false;
3979 typedef PartialSpecMatchResult MatchResult;
3994 bool InstantiationDependent =
false;
3996 TemplateArgs, InstantiationDependent)) {
4001 for (
unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
4014 Matched.push_back(PartialSpecMatchResult());
4015 Matched.back().Partial = Partial;
4016 Matched.back().Args = Info.take();
4020 if (Matched.size() >= 1) {
4022 if (Matched.size() == 1) {
4035 PEnd = Matched.end();
4037 if (getMoreSpecializedPartialSpecialization(
P->Partial, Best->Partial,
4038 PointOfInstantiation) ==
4046 PEnd = Matched.end();
4048 if (
P != Best && getMoreSpecializedPartialSpecialization(
4049 P->Partial, Best->Partial,
4050 PointOfInstantiation) != Best->Partial) {
4051 AmbiguousPartialSpec =
true;
4058 InstantiationPattern = Best->Partial;
4059 InstantiationArgs = Best->Args;
4072 Template, InstantiationPattern, *InstantiationArgs, TemplateArgs,
4073 Converted, TemplateNameLoc, InsertPos );
4077 if (AmbiguousPartialSpec) {
4080 Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
4084 for (MatchResult
P : Matched)
4085 Diag(
P.Partial->getLocation(), diag::note_partial_spec_match)
4086 << getTemplateArgumentBindingsText(
P.Partial->getTemplateParameters(),
4092 dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
4095 checkSpecializationVisibility(TemplateNameLoc, Decl);
4097 assert(Decl &&
"No variable template specialization?");
4118 return BuildDeclarationNameExpr(SS, NameInfo, Var,
4119 nullptr, TemplateArgs);
4124 Diag(Loc, diag::err_template_missing_args)
4125 << (int)getTemplateNameKindForDiagnostics(Name) << Name;
4127 Diag(TD->getLocation(), diag::note_template_decl_here)
4128 << TD->getTemplateParameters()->getSourceRange();
4148 assert(!R.
empty() &&
"empty lookup results when building templateid");
4149 assert(!R.
isAmbiguous() &&
"ambiguous lookup when building templateid");
4153 if (!TemplateArgs && !isa<FunctionTemplateDecl>(TD)) {
4159 auto AnyDependentArguments = [&]() ->
bool {
4160 bool InstantiationDependent;
4161 return TemplateArgs &&
4163 *TemplateArgs, InstantiationDependent);
4170 TemplateKWLoc, TemplateArgs);
4181 RequiresADL, TemplateArgs,
4194 assert(TemplateArgs || TemplateKWLoc.
isValid());
4196 if (!(DC = computeDeclContext(SS,
false)) ||
4197 DC->isDependentContext() ||
4198 RequireCompleteDeclContext(SS, DC))
4199 return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
4201 bool MemberOfUnknownSpecialization;
4204 false, MemberOfUnknownSpecialization,
4218 Diag(NameInfo.
getLoc(), diag::err_template_kw_refers_to_class_template)
4221 Diag(Temp->getLocation(), diag::note_referenced_class_template);
4225 return BuildTemplateIdExpr(SS, TemplateKWLoc, R,
false, TemplateArgs);
4240 bool EnteringContext,
4242 bool AllowInjectedClassName) {
4245 getLangOpts().CPlusPlus11 ?
4246 diag::warn_cxx98_compat_template_outside_of_template :
4247 diag::ext_template_outside_of_template)
4252 LookupCtx = computeDeclContext(SS, EnteringContext);
4253 if (!LookupCtx && ObjectType)
4254 LookupCtx = computeDeclContext(ObjectType.
get());
4272 bool MemberOfUnknownSpecialization;
4274 ObjectType, EnteringContext, Result,
4275 MemberOfUnknownSpecialization);
4284 LookupOrdinaryName);
4286 if (!LookupTemplateName(R, S, SS, ObjectType.get(), EnteringContext,
4287 MOUS, TemplateKWLoc) && !R.isAmbiguous())
4294 if (!AllowInjectedClassName && SS.
isSet() && LookupRD &&
4307 diag::ext_out_of_line_qualified_id_type_names_constructor)
4330 llvm_unreachable(
"literal operator id cannot have a dependent scope");
4336 Diag(Name.
getBeginLoc(), diag::err_template_kw_refers_to_non_template)
4337 << GetNameFromUnqualifiedId(Name).getName() << Name.
getSourceRange()
4364 diagnoseMissingTemplateArguments(Name, SR.
getEnd());
4374 SS.
Adopt(ArgExpr->getQualifierLoc());
4375 NameInfo = ArgExpr->getNameInfo();
4377 dyn_cast<DependentScopeDeclRefExpr>(Arg.
getAsExpr())) {
4378 SS.
Adopt(ArgExpr->getQualifierLoc());
4379 NameInfo = ArgExpr->getNameInfo();
4381 dyn_cast<CXXDependentScopeMemberExpr>(Arg.
getAsExpr())) {
4382 if (ArgExpr->isImplicitAccess()) {
4383 SS.
Adopt(ArgExpr->getQualifierLoc());
4384 NameInfo = ArgExpr->getMemberNameInfo();
4389 LookupResult Result(*
this, NameInfo, LookupOrdinaryName);
4390 LookupParsedName(Result, CurScope, &SS);
4397 Diag(Loc, getLangOpts().MSVCCompat
4398 ? diag::ext_ms_template_type_arg_missing_typename
4399 : diag::err_template_arg_must_be_type_suggest)
4429 Diag(SR.
getBegin(), diag::err_template_arg_must_be_type) << SR;
4436 if (CheckTemplateArgument(Param, TSI))
4445 if (getLangOpts().ObjCAutoRefCount &&
4491 Param, Template, Converted,
4501 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
4506 SemaRef.
SubstType(ArgType, TemplateArgLists,
4543 Param, Template, Converted,
4553 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
4605 for (
unsigned i = 0, e = Param->
getDepth(); i != e; ++i)
4635 bool &HasDefaultArg) {
4636 HasDefaultArg =
false;
4642 HasDefaultArg =
true;
4655 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4659 HasDefaultArg =
true;
4673 = cast<TemplateTemplateParmDecl>(Param);
4677 HasDefaultArg =
true;
4700 if (ETLoc.getTypePtr()->getKeyword() !=
ETK_None)
4703 QualLoc = ETLoc.getQualifierLoc();
4704 TLoc = ETLoc.getNamedTypeLoc();
4711 QualLoc, InjLoc.getNameLoc());
4719 dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))
4721 QualLoc, RecLoc.getNameLoc());
4757 unsigned ArgumentPackIndex,
4762 return CheckTemplateTypeArgument(TTP, Arg, Converted);
4769 QualType NTTPType = NTTP->getType();
4770 if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
4771 NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
4776 !isa<TemplateTemplateParmDecl>(Template) &&
4787 NTTPType = SubstType(NTTPType,
4789 NTTP->getLocation(),
4790 NTTP->getDeclName());
4794 NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
4795 NTTP->getLocation());
4802 llvm_unreachable(
"Should never see a NULL template argument here");
4806 unsigned CurSFINAEErrors = NumSFINAEErrors;
4813 if (CurSFINAEErrors < NumSFINAEErrors)
4823 Converted.push_back(Result);
4857 Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
4869 E = CheckTemplateArgument(NTTP, NTTPType, E.
get(), Result);
4873 Converted.push_back(Result);
4900 Diag(SR.
getBegin(), diag::err_template_arg_nontype_ambig) << SR << T;
4902 Diag(SR.
getBegin(), diag::err_template_arg_must_be_expr) << SR;
4908 llvm_unreachable(
"Caller must expand template argument packs");
4931 TempParm, Converted,
4937 Params = SubstTemplateParams(Params, CurContext,
4956 llvm_unreachable(
"Should never see a NULL template argument here");
4960 if (CheckTemplateTemplateArgument(Params, Arg))
4971 << getLangOpts().CPlusPlus11;
4975 llvm_unreachable(
"Declaration argument with template template parameter");
4977 llvm_unreachable(
"Integral argument with template template parameter");
4979 llvm_unreachable(
"Null pointer argument with template template parameter");
4982 llvm_unreachable(
"Caller must expand template argument packs");
5001 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
5002 if (NTTP->isExpandedParameterPack())
5003 return NTTP->getNumExpansionTypes();
5007 = dyn_cast<TemplateTemplateParmDecl>(Param)) {
5008 if (TTP->isExpandedParameterPack())
5009 return TTP->getNumExpansionTemplateParameters();
5016 template<
typename TemplateParmDecl>
5019 const TemplateParmDecl *D,
5024 ->getTemplateParameters()
5025 ->getParam(D->getIndex()));
5032 D->getDefaultArgumentLoc(), Modules,
5043 S.
Diag(Loc, diag::err_template_arg_list_different_arity)
5058 bool UpdateArgsWithConversions) {
5069 ->getTemplateParameters();
5078 bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
5080 unsigned ArgIdx = 0, NumArgs = NewArgs.
size();
5083 ParamEnd = Params->
end();
5084 Param != ParamEnd; ) {
5088 if (*Expansions == ArgumentPack.size()) {
5091 Converted.push_back(
5093 ArgumentPack.clear();
5098 }
else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
5100 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5102 << (int)getTemplateNameKindForDiagnostics(
TemplateName(Template))
5110 if (ArgIdx < NumArgs) {
5112 if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template,
5113 TemplateLoc, RAngleLoc,
5114 ArgumentPack.size(), Converted))
5117 bool PackExpansionIntoNonPack =
5118 NewArgs[ArgIdx].getArgument().isPackExpansion() &&
5120 if (PackExpansionIntoNonPack && isa<TypeAliasTemplateDecl>(Template)) {
5124 Diag(NewArgs[ArgIdx].getLocation(),
5125 diag::err_alias_template_expansion_into_fixed_list)
5126 << NewArgs[ArgIdx].getSourceRange();
5127 Diag((*Param)->getLocation(), diag::note_template_param_here);
5134 if ((*Param)->isTemplateParameterPack()) {
5139 ArgumentPack.push_back(Converted.pop_back_val());
5148 if (PackExpansionIntoNonPack) {
5149 if (!ArgumentPack.empty()) {
5152 Converted.insert(Converted.end(),
5153 ArgumentPack.begin(), ArgumentPack.end());
5154 ArgumentPack.clear();
5157 while (ArgIdx < NumArgs) {
5158 Converted.push_back(NewArgs[ArgIdx].
getArgument());
5169 if (PartialTemplateArgs) {
5170 if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
5171 Converted.push_back(
5179 if ((*Param)->isTemplateParameterPack()) {
5181 "Should have dealt with this already");
5186 if (Param + 1 != ParamEnd)
5189 Converted.push_back(
5191 ArgumentPack.clear();
5222 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
5239 = cast<TemplateTemplateParmDecl>(*Param);
5265 if (Inst.isInvalid())
5269 if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc,
5270 RAngleLoc, 0, Converted))
5276 if (isTemplateTemplateParameter)
5288 if (ArgIdx < NumArgs && CurrentInstantiationScope &&
5289 CurrentInstantiationScope->getPartiallySubstitutedPack()) {
5291 Converted.push_back(NewArgs[ArgIdx++].getArgument());
5296 if (ArgIdx < NumArgs) {
5297 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5299 << (int)getTemplateNameKindForDiagnostics(
TemplateName(Template))
5309 if (UpdateArgsWithConversions)
5310 TemplateArgs = std::move(NewArgs);
5316 class UnnamedLocalNoLinkageFinder
5317 :
public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
5325 UnnamedLocalNoLinkageFinder(
Sema &S,
SourceRange SR) : S(S), SR(SR) { }
5331 #define TYPE(Class, Parent) \ 5332 bool Visit##Class##Type(const Class##Type *); 5333 #define ABSTRACT_TYPE(Class, Parent) \ 5334 bool Visit##Class##Type(const Class##Type *) { return false; } 5335 #define NON_CANONICAL_TYPE(Class, Parent) \ 5336 bool Visit##Class##Type(const Class##Type *) { return false; } 5337 #include "clang/AST/TypeNodes.def" 5339 bool VisitTagDecl(
const TagDecl *Tag);
5344 bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(
const BuiltinType*) {
5348 bool UnnamedLocalNoLinkageFinder::VisitComplexType(
const ComplexType* T) {
5352 bool UnnamedLocalNoLinkageFinder::VisitPointerType(
const PointerType* T) {
5356 bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
5361 bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
5366 bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
5371 bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
5376 bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
5381 bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
5386 bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
5391 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
5396 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
5401 bool UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(
5406 bool UnnamedLocalNoLinkageFinder::VisitVectorType(
const VectorType* T) {
5410 bool UnnamedLocalNoLinkageFinder::VisitDependentVectorType(
5415 bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(
const ExtVectorType* T) {
5419 bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
5429 bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
5434 bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
5439 bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(
const TypeOfExprType*) {
5443 bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(
const TypeOfType* T) {
5447 bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(
const DecltypeType*) {
5451 bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
5456 bool UnnamedLocalNoLinkageFinder::VisitAutoType(
const AutoType *T) {
5460 bool UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(
5465 bool UnnamedLocalNoLinkageFinder::VisitRecordType(
const RecordType* T) {
5466 return VisitTagDecl(T->
getDecl());
5469 bool UnnamedLocalNoLinkageFinder::VisitEnumType(
const EnumType* T) {
5470 return VisitTagDecl(T->
getDecl());
5473 bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
5478 bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
5483 bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
5488 bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
5490 return VisitTagDecl(T->
getDecl());
5493 bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
5498 bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
5503 bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
5508 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(
const ObjCObjectType *) {
5512 bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
5517 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
5522 bool UnnamedLocalNoLinkageFinder::VisitAtomicType(
const AtomicType* T) {
5526 bool UnnamedLocalNoLinkageFinder::VisitPipeType(
const PipeType* T) {
5530 bool UnnamedLocalNoLinkageFinder::VisitTagDecl(
const TagDecl *Tag) {
5532 S.
Diag(SR.getBegin(),
5534 diag::warn_cxx98_compat_template_arg_local_type :
5535 diag::ext_template_arg_local_type)
5541 S.
Diag(SR.getBegin(),
5543 diag::warn_cxx98_compat_template_arg_unnamed_type :
5544 diag::ext_template_arg_unnamed_type) << SR;
5552 bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
5569 llvm_unreachable(
"Invalid NestedNameSpecifier::Kind!");
5579 assert(ArgInfo &&
"invalid TypeSourceInfo");
5584 return Diag(SR.
getBegin(), diag::err_variably_modified_template_arg) << Arg;
5586 return Diag(SR.
getBegin(), diag::err_template_arg_overload_type) << SR;
5597 UnnamedLocalNoLinkageFinder Finder(*
this, SR);
5615 Decl *Entity =
nullptr) {
5621 if (Entity && Entity->hasAttr<DLLImportAttr>())
5626 "Incomplete parameter type in isNullPointerValueTemplateArgument!");
5639 EvalResult.
Diag = &Notes;
5647 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
5648 diag::note_invalid_subexpr_in_const_expr) {
5649 DiagLoc = Notes[0].first;
5653 S.
Diag(DiagLoc, diag::err_template_arg_not_address_constant)
5655 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
5656 S.
Diag(Notes[I].first, Notes[I].second);
5674 bool ObjCLifetimeConversion;
5677 ObjCLifetimeConversion))
5682 S.
Diag(Arg->
getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
5691 std::string Code =
"static_cast<" + ParamType.
getAsString() +
">(";
5692 S.
Diag(Arg->
getExprLoc(), diag::err_template_arg_untyped_null_constant)
5711 bool ObjCLifetimeConversion;
5715 ObjCLifetimeConversion)) {
5720 if (!ParamRef->getPointeeType()->isFunctionType()) {
5730 unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
5733 if ((ParamQuals | ArgQuals) != ParamQuals) {
5735 diag::err_template_arg_ref_bind_ignores_quals)