RetroSearch Browse

= dyn_cast<CXXRecordDecl>(

)) {

126 if

(

->isInjectedClassName()) {

127 Record

= cast<CXXRecordDecl>(

->getDeclContext());

128 if

(

->getDescribedClassTemplate())

129 return Record

->getDescribedClassTemplate();

131 if

(

const auto

*Spec = dyn_cast<ClassTemplateSpecializationDecl>(

))

132 return

Spec->getSpecializedTemplate();

141 if

(AllowDependent && isa<UnresolvedUsingValueDecl>(

))

148 bool

AllowFunctionTemplates,

149 bool

AllowDependent) {

160 bool

AllowFunctionTemplates,

162 bool

AllowNonTemplateFunctions) {

166 if

(AllowNonTemplateFunctions &&

167

isa<FunctionDecl>((*I)->getUnderlyingDecl()))

176 bool

hasTemplateKeyword,

179 bool

EnteringContext,

181 bool

&MemberOfUnknownSpecialization,

182 bool

Disambiguation) {

186

MemberOfUnknownSpecialization =

false

;

188 switch

(Name.getKind()) {

195

Name.OperatorFunctionId.Operator);

235 bool

AnyFunctionTemplates =

false

;

238 if

(isa<FunctionTemplateDecl>(FoundTemplate))

239

AnyFunctionTemplates =

true

;

242

FoundUsingShadow = dyn_cast<UsingShadowDecl>(FoundD);

250 if

&& !AnyFunctionTemplates) {

251

R.suppressDiagnostics();

268 unsigned

ResultCount = R.

() - R.

();

269 if

&& ResultCount > 1) {

280

assert(

"unambiguous result is not a template name"

);

283 if

(isa<UnresolvedUsingValueDecl>(

)) {

285

MemberOfUnknownSpecialization =

true

;

292

assert(!FoundUsingShadow || FoundUsingShadow->

getTargetDecl

() == TD);

299 if

(isa<FunctionTemplateDecl>(TD)) {

305

assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||

306

isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||

307

isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD));

330 if

(R.

())

return false

;

367 Diag

(IILoc, diag::err_template_kw_missing)

377 QualType

ObjectType,

bool

EnteringContext,

380 bool

AllowTypoCorrection) {

387 Found

.setTemplateNameLookup(

true

);

391 bool

IsDependent =

false

;

392 if

(!ObjectType.

()) {

395

assert(SS.

isEmpty

() &&

"ObjectType and scope specifier cannot coexist"

);

401 "Caller should have completed object type"

);

433 bool

ObjectTypeSearchedInScope =

false

;

434 bool

AllowFunctionTemplatesInLookup =

true

;

450

IsDependent |=

.wasNotFoundInCurrentInstantiation();

466 if

(!ObjectType.

()) {

470

AllowFunctionTemplatesInLookup =

false

;

471

ObjectTypeSearchedInScope =

true

;

474

IsDependent |=

.wasNotFoundInCurrentInstantiation();

477 if

(

.isAmbiguous())

494 if

(AllFunctions || (

.empty() && !IsDependent)) {

498

*ATK = (

.empty() &&

.getLookupName().isIdentifier())

506 if

(

.empty() && !IsDependent && AllowTypoCorrection) {

514

FilterCCC.WantExpressionKeywords =

false

;

515

FilterCCC.WantRemainingKeywords =

false

;

516

FilterCCC.WantCXXNamedCasts =

true

;

520 if

(

auto

*ND = Corrected.getFoundDecl())

523 if

(

.isAmbiguous()) {

525

}

else if

.empty()) {

526 Found

.setLookupName(Corrected.getCorrection());

528

std::string CorrectedStr(Corrected.getAsString(

()));

529 bool

DroppedSpecifier = Corrected.WillReplaceSpecifier() &&

530

Name.getAsString() == CorrectedStr;

532

<< Name << LookupCtx << DroppedSpecifier

542 Found

.empty() ? nullptr :

.getRepresentativeDecl();

544 if

(

.empty()) {

546 Found

.setNotFoundInCurrentInstantiation();

552 if

(ExampleLookupResult && RequiredTemplate) {

553 Diag

(

.getNameLoc(), diag::err_template_kw_refers_to_non_template)

558

diag::note_template_kw_refers_to_non_template)

559

.getLookupName();

566 if

(S && !ObjectType.

() && !ObjectTypeSearchedInScope &&

583 if

(FoundOuter.

()) {

592

FoundOuter.

clear

();

593

}

else if

.isSuppressingAmbiguousDiagnostics()) {

597 if

.isSingleResult() ||

601

diag::ext_nested_name_member_ref_lookup_ambiguous)

602

.getLookupName()

604 Diag

(

.getRepresentativeDecl()->getLocation(),

605

diag::note_ambig_member_ref_object_type)

608

diag::note_ambig_member_ref_scope);

631 bool

MissingTemplateKeyword =

false

;

634 if

(

auto

*DRE = dyn_cast<DeclRefExpr>(

.get())) {

635

NameInfo = DRE->getNameInfo();

636

SS.

(DRE->getQualifierLoc());

638 Found

= DRE->getFoundDecl();

639

}

else if

(

auto

*ME = dyn_cast<MemberExpr>(

.get())) {

640

NameInfo = ME->getMemberNameInfo();

641

SS.

(ME->getQualifierLoc());

643

LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();

644 Found

= ME->getMemberDecl();

645

}

else if

(

auto

*DSDRE =

646

dyn_cast<DependentScopeDeclRefExpr>(

.get())) {

647

NameInfo = DSDRE->getNameInfo();

648

SS.

(DSDRE->getQualifierLoc());

649

MissingTemplateKeyword =

true

;

650

}

else if

(

auto

*DSME =

651

dyn_cast<CXXDependentScopeMemberExpr>(

.get())) {

652

NameInfo = DSME->getMemberNameInfo();

653

SS.

(DSME->getQualifierLoc());

654

MissingTemplateKeyword =

true

;

656

llvm_unreachable(

"unexpected kind of potential template name"

);

661 if

(MissingTemplateKeyword) {

670

TemplateCandidateFilter(

&S) : S(S) {

671

WantTypeSpecifiers =

false

;

672

WantExpressionKeywords =

false

;

673

WantRemainingKeywords =

false

;

674

WantCXXNamedCasts =

true

;

676 bool

ValidateCandidate(

const TypoCorrection

&Candidate)

override

{

682

std::unique_ptr<CorrectionCandidateCallback> clone()

override

{

683 return

std::make_unique<TemplateCandidateFilter>(*

this

);

688

TemplateCandidateFilter CCC(*

this

);

691 auto

*ND = Corrected.getFoundDecl();

694 if

(ND || Corrected.isKeyword()) {

696

std::string CorrectedStr(Corrected.getAsString(

()));

697 bool

DroppedSpecifier = Corrected.WillReplaceSpecifier() &&

698

Name.getAsString() == CorrectedStr;

700 PDiag

(diag::err_non_template_in_member_template_id_suggest)

701

<< Name << LookupCtx << DroppedSpecifier

705 PDiag

(diag::err_non_template_in_template_id_suggest)

710

diag::note_non_template_in_template_id_found);

715 Diag

(NameInfo.

getLoc

(), diag::err_non_template_in_template_id)

718 Diag

(

->getLocation(), diag::note_non_template_in_template_id_found);

725 bool

isAddressOfOperand,

741 nullptr

, NameInfo, TemplateArgs);

764 bool

InstantiatedFromMember,

769

assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||

770

isa<VarDecl>(Instantiation));

772 bool

IsEntityBeingDefined =

false

;

773 if

(

const TagDecl

*TD = dyn_cast_or_null<TagDecl>(PatternDef))

774

IsEntityBeingDefined = TD->isBeingDefined();

776 if

(PatternDef && !IsEntityBeingDefined) {

791 if

(!Complain || (PatternDef && PatternDef->

isInvalidDecl

()))

795 if

(

TagDecl

*TD = dyn_cast<TagDecl>(Instantiation))

798 Diag

(PointOfInstantiation,

799

diag::err_template_instantiate_within_definition)

805

}

else if

(InstantiatedFromMember) {

806 if

(isa<FunctionDecl>(Instantiation)) {

807 Diag

(PointOfInstantiation,

808

diag::err_explicit_instantiation_undefined_member)

811 Diag

(Pattern->

(), diag::note_explicit_instantiation_here);

813

assert(isa<TagDecl>(Instantiation) &&

"Must be a TagDecl!"

);

814 Diag

(PointOfInstantiation,

815

diag::err_implicit_instantiate_member_undefined)

820 if

(isa<FunctionDecl>(Instantiation)) {

821 Diag

(PointOfInstantiation,

822

diag::err_explicit_instantiation_undefined_func_template)

824 Diag

(Pattern->

(), diag::note_explicit_instantiation_here);

825

}

else if

(isa<TagDecl>(Instantiation)) {

826 Diag

(PointOfInstantiation, diag::err_template_instantiate_undefined)

831

assert(isa<VarDecl>(Instantiation) &&

"Must be a VarDecl!"

);

832 if

(isa<VarTemplateSpecializationDecl>(Instantiation)) {

833 Diag

(PointOfInstantiation,

834

diag::err_explicit_instantiation_undefined_var_template)

838 Diag

(PointOfInstantiation,

839

diag::err_explicit_instantiation_undefined_member)

842 Diag

(Pattern->

(), diag::note_explicit_instantiation_here);

856 bool

SupportedForCompatibility) {

869

? diag::ext_template_param_shadow

870

: (SupportedForCompatibility ? diag::ext_compat_template_param_shadow

871

: diag::err_template_param_shadow);

872 const auto

*ND = cast<NamedDecl>(PrevDecl);

873 Diag

(

, DiagId) << ND->getDeclName();

878 if

(

*Temp = dyn_cast_or_null<TemplateDecl>(

)) {

879 D

= Temp->getTemplatedDecl();

888 "Only template template arguments can be pack expansions here"

);

889

assert(

getAsTemplate

().get().containsUnexpandedParameterPack() &&

890 "Template template argument pack expansion without packs"

);

892 Result

.EllipsisLoc = EllipsisLoc;

927

llvm_unreachable(

"Unhandled parsed template argument"

);

932 for

(

unsigned

I = 0,

Last

= TemplateArgsIn.size(); I !=

Last

; ++I)

942

RedeclarationKind::ForVisibleRedeclaration);

952

assert(TInfo &&

"template argument with no location"

);

960

EllipsisLoc = PET.getEllipsisLoc();

961

TL = PET.getPatternLoc();

966

SS.

(ET.getQualifierLoc());

967

TL = ET.getNamedTypeLoc();

971 TemplateName

Name = DTST.getTypePtr()->getTemplateName();

973

DTST.getTemplateNameLoc());

994 unsigned

Depth,

unsigned

Position,

997 bool

HasTypeConstraint) {

998

assert(S->isTemplateParamScope() &&

999 "Template type parameter not in template parameter scope!"

);

1001 bool

IsParameterPack = EllipsisLoc.

();

1004

KeyLoc, ParamNameLoc, Depth, Position,

1005

ParamName,

Typename

, IsParameterPack,

1011

CSI->LocalPacks.push_back(Param);

1024 if

(DefaultArg && IsParameterPack) {

1025 Diag

(EqualLoc, diag::err_template_param_pack_default_arg);

1026

DefaultArg =

nullptr

;

1034

assert(DefaultTInfo &&

"expected source information for type"

);

1062 return

TemplateArgs;

1075

diag::err_type_constraint_non_type_concept);

1084 if

(!WereArgsSpecified &&

1087

diag::err_type_constraint_missing_arguments)

1106 bool

AllowUnexpandedPack) {

1123 if

(EllipsisLoc.

() && !AllowUnexpandedPack) {

1132

ConceptName, CD,

USD ? cast<NamedDecl>(USD) : CD,

1138template

typename

ArgumentLocAppender>

1153

Appender(ConstraintArgs);

1162

FoundDecl ? FoundDecl : NamedConcept, NamedConcept,

1164 if

(ImmediatelyDeclaredConstraint.

() || !EllipsisLoc.

())

1165 return

ImmediatelyDeclaredConstraint;

1181

ImmediatelyDeclaredConstraint.

(), BO_LAnd,

1182

EllipsisLoc,

nullptr

1199

*TemplateArgs) :

nullptr

;

1201 QualType

ParamAsArgument = ConstrainedType;

1204

this

, NameInfo, NamedConcept, FoundDecl,

1207

ParamAsArgument, ConstrainedParameter->

(),

1210

for (const auto &ArgLoc : TemplateArgs->arguments())

1211

ConstraintArgs.addArgument(ArgLoc);

1214 if

(ImmediatelyDeclaredConstraint.

())

1224

ImmediatelyDeclaredConstraint.

());

1235

diag::err_unsupported_placeholder_constraint)

1254

for (unsigned I = 0, C = TL.getNumArgs(); I != C; ++I)

1255

ConstraintArgs.addArgument(TL.getArgLoc(I));

1258 if

(ImmediatelyDeclaredConstraint.

() ||

1259

!ImmediatelyDeclaredConstraint.

isUsable

())

1263

ImmediatelyDeclaredConstraint.

());

1293 Diag

(

, diag::err_template_nontype_parm_rvalue_ref) <<

;

1303 Diag

(

, diag::err_template_nontype_parm_bad_type) <<

;

1311 Diag

(

, diag::err_template_nontype_parm_not_structural) <<

;

1318 for

(

const FieldDecl

*FD : RD->fields()) {

1320 Diag

(FD->getLocation(), diag::note_not_structural_non_public) <<

<< 0;

1323 if

(FD->isMutable()) {

1324 Diag

(FD->getLocation(), diag::note_not_structural_mutable_field) <<

;

1327 if

(FD->getType()->isRValueReferenceType()) {

1328 Diag

(FD->getLocation(), diag::note_not_structural_rvalue_ref_field)

1335 for

(

const auto

&BaseSpec : RD->bases()) {

1336 if

(BaseSpec.getAccessSpecifier() !=

AS_public

) {

1337 Diag

(BaseSpec.getBaseTypeLoc(), diag::note_not_structural_non_public)

1348 for

(

const FieldDecl

*FD : RD->fields()) {

1351

SubLoc = FD->getLocation();

1359 for

(

const auto

&BaseSpec : RD->bases()) {

1362

SubLoc = BaseSpec.getBaseTypeLoc();

1370

assert(Kind != -1 &&

"couldn't find reason why type is not structural"

);

1371 Diag

(SubLoc, diag::note_not_structural_subobject)

1372

<< Kind << SubType;

1385 Diag

(

, diag::err_variably_modified_nontype_template_param)

1409 return T

.getUnqualifiedType();

1427 return T

.getUnqualifiedType();

1438 Diag

(

, diag::err_template_nontype_parm_bad_structural_type) <<

;

1442 Diag

(

, diag::warn_cxx17_compat_template_nontype_parm_type) <<

;

1443 return T

.getUnqualifiedType();

1454 auto

CheckValidDeclSpecifiers = [

this

, &

] {

1468 Diag

(

, diag::err_invalid_decl_specifier_in_nontype_parm)

1505

CheckValidDeclSpecifiers();

1508 if

(isa<AutoType>(

))

1509 Diag

(

.getIdentifierLoc(),

1510

diag::warn_cxx14_compat_template_nontype_parm_auto_type)

1513

assert(S->isTemplateParamScope() &&

1514 "Non-type template parameter not in template parameter scope!"

);

1526 bool

IsParameterPack =

.hasEllipsis();

1529 D

.getIdentifierLoc(), Depth, Position, ParamName,

, IsParameterPack,

1534 if

(TL.isConstrained()) {

1535 if

(

.getEllipsisLoc().isInvalid() &&

1537

assert(TL.getConceptReference()->getTemplateArgsAsWritten());

1539

TL.getConceptReference()->getTemplateArgsAsWritten()->arguments())

1553

CSI->LocalPacks.push_back(Param);

1567 if

(

Default

&& IsParameterPack) {

1568 Diag

(EqualLoc, diag::err_template_param_pack_default_arg);

1591

assert(S->isTemplateParamScope() &&

1592 "Template template parameter not in template parameter scope!"

);

1595 bool

IsParameterPack = EllipsisLoc.

();

1598

NameLoc.

() ? TmpLoc : NameLoc, Depth, Position, IsParameterPack,

1604

LSI->LocalPacks.push_back(Param);

1615 if

(Params->

() == 0) {

1616 Diag

(Param->

(), diag::err_template_template_parm_no_parms)

1624 if

(IsParameterPack && !

Default

.isInvalid()) {

1625 Diag

(EqualLoc, diag::err_template_param_pack_default_arg);

1640 Diag

(DefaultArg.

(), diag::err_template_arg_not_valid_template)

1658class

ConstraintRefersToContainingTemplateChecker

1659

public TreeTransform

<ConstraintRefersToContainingTemplateChecker> {

1660 bool

Result =

false

;

1662 unsigned

TemplateDepth = 0;

1666 void

CheckIfContainingRecord(

const CXXRecordDecl

*CheckingRD) {

1672

DC && !DC->isFileContext(); DC = DC->getParent())

1673 if

(

const auto

*RD = dyn_cast<CXXRecordDecl>(DC))

1674 if

(CheckingRD == RD->getMostRecentDecl())

1679 if

(

->getDepth() < TemplateDepth)

1684

TransformType(

->getType());

1690

ConstraintRefersToContainingTemplateChecker(

&SemaRef,

1692 unsigned

TemplateDepth)

1693

: inherited(SemaRef),

(

), TemplateDepth(TemplateDepth) {}

1694 bool

getResult()

const

{

return

Result; }

1700 using

inherited::TransformTemplateTypeParmType;

1705 return

inherited::TransformTemplateTypeParmType(

1717 if

(

auto

*TD = dyn_cast<TypedefNameDecl>(

))

1718

TransformType(TD->getUnderlyingType());

1719 else if

(

auto

*NTTPD = dyn_cast<NonTypeTemplateParmDecl>(

))

1720

CheckNonTypeTemplateParmDecl(NTTPD);

1721 else if

(

auto

*VD = dyn_cast<ValueDecl>(

))

1722

TransformType(VD->getType());

1723 else if

(

auto

*TD = dyn_cast<TemplateDecl>(

))

1724

TransformTemplateParameterList(TD->getTemplateParameters());

1725 else if

(

auto

*RD = dyn_cast<CXXRecordDecl>(

))

1726

CheckIfContainingRecord(RD);

1727 else if

(isa<NamedDecl>(

)) {

1730

llvm_unreachable(

"Don't know how to handle this declaration type yet"

);

1738 const Expr

*Constraint) {

1739

assert(

->getFriendObjectKind() &&

"Only works on a friend"

);

1740

ConstraintRefersToContainingTemplateChecker Checker(*

this

1742

Checker.TransformExpr(

const_cast<Expr

>

(Constraint));

1743 return

Checker.getResult();

1753 Expr

*RequiresClause) {

1755 Diag

(ExportLoc, diag::warn_template_export_unsupported);

1761 Context

, TemplateLoc, LAngleLoc,

1762 llvm::ArrayRef

(Params.data(), Params.size()), RAngleLoc, RequiresClause);

1797 return

cast<TemplateDecl>(

)->getTemplateParameters();

1807

assert(TemplateParams && TemplateParams->

() > 0 &&

1808 "No template parameters"

);

1810 "Can only declare or define class templates"

);

1819 "can't build template of enumerated type"

);

1823 Diag

(KWLoc, diag::err_template_unnamed_class);

1838 if

(!SemanticContext) {

1843

? diag::warn_template_qualified_friend_ignored

1844

: diag::err_template_qualified_declarator_no_match)

1856 ContextRAII

SavedContext(*

this

, SemanticContext);

1903 if

(S->isTemplateParamScope())

1908

PrevDecl = (*

.begin())->getUnderlyingDecl();

1914

PrevDecl =

nullptr

;

1920

dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);

1925 if

(!PrevClassTemplate && isa_and_nonnull<CXXRecordDecl>(PrevDecl) &&

1926

cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {

1929

= cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();

1930 if

(!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {

1932

= cast<ClassTemplateSpecializationDecl>(PrevDecl)

1933

->getSpecializedTemplate();

1943 if

(!SS.

()) {

1956

PrevDecl = PrevClassTemplate =

nullptr

;

1957

SemanticContext = OutermostContext;

1971

PrevDecl = (*

.begin())->getUnderlyingDecl();

1975

SemanticContext, S, SS.

()))

1976

PrevDecl = PrevClassTemplate =

nullptr

;

1978 if

(

auto

*Shadow = dyn_cast_or_null<UsingShadowDecl>(

1979

PrevDecl ?

.getRepresentativeDecl() :

nullptr

)) {

1981

!(PrevClassTemplate &&

1984 Diag

(KWLoc, diag::err_using_decl_conflict_reverse);

1985 Diag

(Shadow->getTargetDecl()->getLocation(),

1986

diag::note_using_decl_target);

1987 Diag

(Shadow->getIntroducer()->getLocation(), diag::note_using_decl) << 0;

1989

PrevDecl = PrevClassTemplate =

nullptr

;

1993 if

(PrevClassTemplate) {

2002

TemplateParams, PrevClassTemplate,

2015 Diag

(KWLoc, diag::err_use_with_wrong_tag)

2031 auto

*Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();

2032

assert(Tmpl &&

"original definition of a class template is not a " 2033 "class template?"

);

2037 Diag

(NameLoc, diag::err_redefinition) << Name;

2038 Diag

(Def->getLocation(), diag::note_previous_definition);

2045

}

else if

(PrevDecl) {

2051 Diag

(NameLoc, diag::err_redefinition_different_kind) << Name;

2065

(SS.

() && SemanticContext && SemanticContext->

isRecord

() &&

2078

? diag::err_friend_decl_does_not_match

2079

: diag::err_member_decl_does_not_match)

2080

<< Name << SemanticContext <<

true

<< SS.

getRange

();

2090 bool

ShouldAddRedecl =

2095

PrevClassTemplate && ShouldAddRedecl ?

2099 if

(NumOuterTemplateParamLists > 0)

2102 llvm::ArrayRef

(OuterTemplateParamLists, NumOuterTemplateParamLists));

2116 if

(ShouldAddRedecl)

2121 if

(ModulePrivateLoc.

())

2127

assert(

isDependentType

() &&

"Class template type is not dependent?"

);

2132 if

(PrevClassTemplate &&

2150 if

(PrevClassTemplate)

2186 if

(PrevClassTemplate)

2227

diag::warn_cxx98_compat_template_parameter_default_in_function_template

2228

: diag::ext_template_parameter_default_in_function_template)

2237

(ParamLoc, diag::err_template_parameter_default_template_member)

2246

(ParamLoc, diag::err_template_parameter_default_friend_template)

2255

llvm_unreachable(

"Invalid TemplateParamListContext!"

);

2268 for

(

unsigned

I = 0, N = Params->

(); I != N; ++I) {

2273 if

(TC->hasExplicitTemplateArgs())

2274 for

(

auto

&ArgLoc : TC->getTemplateArgsAsWritten()->arguments())

2282 if

(!NTTP->isParameterPack() &&

2284

NTTP->getTypeSourceInfo(),

2292

= dyn_cast<TemplateTemplateParmDecl>(

))

2312 bool

SawDefaultArgument =

false

;

2318

OldParam = OldParams->

();

2320 bool

RemoveDefaultArguments =

false

;

2322

NewParamEnd = NewParams->

();

2323

NewParam != NewParamEnd; ++NewParam) {

2326 bool

RedundantDefaultArg =

false

;

2329 bool

InconsistentDefaultArg =

false

;

2331

std::string PrevModuleName;

2337 bool

MissingDefaultArg =

false

;

2340 bool

SawParameterPack =

false

;

2343

= dyn_cast<TemplateTypeParmDecl>(*NewParam)) {

2345 if

(NewTypeParm->hasDefaultArgument() &&

2347

this

, TPC, NewTypeParm->getLocation(),

2348

NewTypeParm->getDefaultArgument().getSourceRange()))

2349

NewTypeParm->removeDefaultArgument();

2353

= OldParams? cast<TemplateTypeParmDecl>(*OldParam) :

nullptr

;

2354 if

(NewTypeParm->isParameterPack()) {

2355

assert(!NewTypeParm->hasDefaultArgument() &&

2356 "Parameter packs can't have a default argument!"

);

2357

SawParameterPack =

true

;

2359

NewTypeParm->hasDefaultArgument() &&

2362

NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();

2363

SawDefaultArgument =

true

;

2366

RedundantDefaultArg =

true

;

2367 else if

getASTContext

().isSameDefaultTemplateArgument(OldTypeParm,

2369

InconsistentDefaultArg =

true

;

2373

PreviousDefaultArgLoc = NewDefaultLoc;

2377

NewTypeParm->setInheritedDefaultArgument(

Context

, OldTypeParm);

2379

}

else if

(NewTypeParm->hasDefaultArgument()) {

2380

SawDefaultArgument =

true

;

2381

PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();

2382

}

else if

(SawDefaultArgument)

2383

MissingDefaultArg =

true

;

2385

= dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {

2387 if

(!NewNonTypeParm->isParameterPack() &&

2389

NewNonTypeParm->getTypeSourceInfo(),

2396 if

(NewNonTypeParm->hasDefaultArgument() &&

2398

this

, TPC, NewNonTypeParm->getLocation(),

2399

NewNonTypeParm->getDefaultArgument().getSourceRange())) {

2400

NewNonTypeParm->removeDefaultArgument();

2405

= OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) :

nullptr

;

2406 if

(NewNonTypeParm->isParameterPack()) {

2407

assert(!NewNonTypeParm->hasDefaultArgument() &&

2408 "Parameter packs can't have a default argument!"

);

2409 if

(!NewNonTypeParm->isPackExpansion())

2410

SawParameterPack =

true

;

2412

NewNonTypeParm->hasDefaultArgument() &&

2415

NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();

2416

SawDefaultArgument =

true

;

2418

RedundantDefaultArg =

true

;

2420

OldNonTypeParm, NewNonTypeParm)) {

2421

InconsistentDefaultArg =

true

;

2425

PreviousDefaultArgLoc = NewDefaultLoc;

2429

NewNonTypeParm->setInheritedDefaultArgument(

Context

, OldNonTypeParm);

2431

}

else if

(NewNonTypeParm->hasDefaultArgument()) {

2432

SawDefaultArgument =

true

;

2433

PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();

2434

}

else if

(SawDefaultArgument)

2435

MissingDefaultArg =

true

;

2438

= cast<TemplateTemplateParmDecl>(*NewParam);

2455

= OldParams? cast<TemplateTemplateParmDecl>(*OldParam) :

nullptr

;

2458 "Parameter packs can't have a default argument!"

);

2460

SawParameterPack =

true

;

2461

}

else if

(OldTemplateParm &&

2467

SawDefaultArgument =

true

;

2469

RedundantDefaultArg =

true

;

2471

OldTemplateParm, NewTemplateParm)) {

2472

InconsistentDefaultArg =

true

;

2476

PreviousDefaultArgLoc = NewDefaultLoc;

2481

PreviousDefaultArgLoc

2484

SawDefaultArgument =

true

;

2485

PreviousDefaultArgLoc

2487

}

else if

(SawDefaultArgument)

2488

MissingDefaultArg =

true

;

2494 if

(SawParameterPack && (NewParam + 1) != NewParamEnd &&

2497 Diag

((*NewParam)->getLocation(),

2498

diag::err_template_param_pack_must_be_last_template_parameter);

2515 if

(RedundantDefaultArg) {

2516 Diag

(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);

2517 Diag

(OldDefaultLoc, diag::note_template_param_prev_default_arg);

2519

}

else if

(InconsistentDefaultArg) {

2522 Diag

(NewDefaultLoc,

2523

diag::err_template_param_default_arg_inconsistent_redefinition);

2524 Diag

(OldDefaultLoc,

2525

diag::note_template_param_prev_default_arg_in_other_module)

2528

}

else if

(MissingDefaultArg &&

2536 Diag

((*NewParam)->getLocation(),

2537

diag::err_template_param_default_arg_missing);

2538 Diag

(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);

2540

RemoveDefaultArguments =

true

;

2551 if

(RemoveDefaultArguments) {

2553

NewParamEnd = NewParams->

();

2554

NewParam != NewParamEnd; ++NewParam) {

2556

TTP->removeDefaultArgument();

2558

= dyn_cast<NonTypeTemplateParmDecl>(*NewParam))

2559

NTTP->removeDefaultArgument();

2561

cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();

2579 bool

IgnoreNonTypeDependent;

2584

DependencyChecker(

unsigned

Depth,

bool

IgnoreNonTypeDependent)

2585

: Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),

2589

: IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(

false

) {

2592

Depth = PD->getDepth();

2594

dyn_cast<NonTypeTemplateParmDecl>(ND)) {

2595

Depth = PD->getDepth();

2597

Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();

2602 if

(ParmDepth >= Depth) {

2610 bool

TraverseStmt(

Stmt

*S)

override

{

2615 if

(

auto

= dyn_cast_or_null<Expr>(S))

2621 bool

TraverseTypeLoc(

TypeLoc

TL)

override

{

2622 if

(IgnoreNonTypeDependent && !TL.

() &&

2634 return

IgnoreNonTypeDependent || !Matches(

->getDepth());

2640 if

(Matches(PD->getDepth()))

2647

dyn_cast<NonTypeTemplateParmDecl>(

->getDecl()))

2650 return

DynamicRecursiveASTVisitor::VisitDeclRefExpr(

);

2654 return

TraverseType(

->getReplacementType());

2657 bool

VisitSubstTemplateTypeParmPackType(

2659 return

TraverseTemplateArgument(

->getArgumentPack());

2663 return

TraverseType(

->getInjectedSpecializationType());

2672 if

(!Params->

())

2675

DependencyChecker Checker(Params,

false

);

2676

Checker.TraverseType(

);

2677 return

Checker.Match;

2687 if

(

const Type

*CurType = NNS->getAsType()) {

2703 bool

&IsMemberSpecialization,

bool

Invalid

bool

SuppressDiagnostic) {

2704

IsMemberSpecialization =

false

;

2725 while

.isNull()) {

2726

NestedTypes.push_back(

);

2732

= dyn_cast<ClassTemplateSpecializationDecl>(

)) {

2733 if

(!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&

2735

ExplicitSpecLoc = Spec->getLocation();

2738

}

else if

(

->getTemplateSpecializationKind()

2740

ExplicitSpecLoc =

->getLocation();

2753 if

(

*Template = TST->getTemplateName().getAsTemplateDecl()) {

2754 if

(

TypeDecl

Parent

= dyn_cast<TypeDecl>(Template->getDeclContext()))

2799

std::reverse(NestedTypes.begin(), NestedTypes.end());

2807 bool

SawNonEmptyTemplateParameterList =

false

;

2809 auto

CheckExplicitSpecialization = [&](

SourceRange Range

bool

Recovery) {

2810 if

(SawNonEmptyTemplateParameterList) {

2811 if

(!SuppressDiagnostic)

2812 Diag

(DeclLoc, diag::err_specialize_member_of_template)

2813

<< !Recovery <<

Range

;

2815

IsMemberSpecialization =

false

;

2824 if

(CheckExplicitSpecialization(

Range

true

))

2829 if

(!ParamLists.empty())

2830

ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();

2832

ExpectedTemplateLoc = DeclStartLoc;

2834 if

(!SuppressDiagnostic)

2835 Diag

(DeclLoc, diag::err_template_spec_needs_header)

2842 for

(

unsigned

TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;

2844 T

= NestedTypes[TypeIdx];

2847 bool

NeedEmptyTemplateHeader =

false

;

2850 bool

NeedNonemptyTemplateHeader =

false

;

2863

= dyn_cast<ClassTemplatePartialSpecializationDecl>(

)) {

2864

ExpectedTemplateParams = Partial->getTemplateParameters();

2865

NeedNonemptyTemplateHeader =

true

;

2866

}

else if

(

->isDependentType()) {

2867 if

(

->getDescribedClassTemplate()) {

2868

ExpectedTemplateParams =

->getDescribedClassTemplate()

2869

->getTemplateParameters();

2870

NeedNonemptyTemplateHeader =

true

;

2873

= dyn_cast<ClassTemplateSpecializationDecl>(

)) {

2879

NeedEmptyTemplateHeader =

true

;

2882

}

else if

(

->getTemplateSpecializationKind()) {

2883 if

(

->getTemplateSpecializationKind()

2885

TypeIdx == NumTypes - 1)

2886

IsMemberSpecialization =

true

;

2892 if

(

*Template = TST->getTemplateName().getAsTemplateDecl()) {

2893

ExpectedTemplateParams = Template->getTemplateParameters();

2894

NeedNonemptyTemplateHeader =

true

;

2899

NeedNonemptyTemplateHeader =

false

;

2909 if

(

< ParamLists.size()) {

2910 if

(ParamLists[

]->size() == 0) {

2911 if

(CheckExplicitSpecialization(ParamLists[

]->getSourceRange(),

2915

SawNonEmptyTemplateParameterList =

true

;

2918 if

(NeedEmptyTemplateHeader) {

2921 if

(TypeIdx == NumTypes - 1)

2922

IsMemberSpecialization =

true

;

2924 if

(

< ParamLists.size()) {

2925 if

(ParamLists[

]->size() > 0) {

2927 if

(!SuppressDiagnostic)

2929

diag::err_template_param_list_matches_nontemplate)

2932

ParamLists[

]->getRAngleLoc())

2944 if

(DiagnoseMissingExplicitSpecialization(

2951 if

(NeedNonemptyTemplateHeader) {

2957 if

(

< ParamLists.size() &&

2959

ExpectedTemplateParams =

nullptr

;

2964 if

(

< ParamLists.size()) {

2966 if

(ExpectedTemplateParams &&

2968

ExpectedTemplateParams,

2981 if

(!SuppressDiagnostic)

2982 Diag

(DeclLoc, diag::err_template_spec_needs_template_parameters)

2993 if

(

>= ParamLists.size()) {

2994 if

(TemplateId && !IsFriend) {

3010 if

(

< ParamLists.size() - 1) {

3011 bool

HasAnyExplicitSpecHeader =

false

;

3012 bool

AllExplicitSpecHeaders =

true

;

3013 for

(

unsigned

I =

= ParamLists.size() - 1; I !=

; ++I) {

3014 if

(ParamLists[I]->size() == 0)

3015

HasAnyExplicitSpecHeader =

true

;

3017

AllExplicitSpecHeaders =

false

;

3020 if

(!SuppressDiagnostic)

3022

AllExplicitSpecHeaders ? diag::ext_template_spec_extra_headers

3023

: diag::err_template_spec_extra_headers)

3025

ParamLists[ParamLists.size() - 2]->getRAngleLoc());

3030 if

(ExplicitSpecLoc.

() && HasAnyExplicitSpecHeader &&

3031

!SuppressDiagnostic)

3032 Diag

(ExplicitSpecLoc,

3033

diag::note_explicit_template_spec_does_not_need_header)

3034

<< NestedTypes.back();

3039 if

(!AllExplicitSpecHeaders)

3050 if

(ParamLists.back()->size() == 0 &&

3051

CheckExplicitSpecialization(ParamLists[

]->getSourceRange(),

3057 return

ParamLists.back();

3061 if

(

*Template = Name.getAsTemplateDecl()) {

3062 Diag

(Template->getLocation(), diag::note_template_declared_here)

3063

<< (isa<FunctionTemplateDecl>(Template)

3065

: isa<ClassTemplateDecl>(Template)

3067

: isa<VarTemplateDecl>(Template)

3069

: isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)

3070

<< Template->getDeclName();

3078 Diag

((*I)->getLocation(), diag::note_template_declared_here)

3079

<< 0 << (*I)->getDeclName();

3112 return

BaseTemplateInst;

3117 switch

(Ts.size()) {

3127 return

lookUpCommonType(Ts[0], Ts[0]);

3141 return

lookUpCommonType(D1, D2);

3146 auto

CheckConditionalOperands = [&](

bool

ConstRefQual) ->

QualType

{

3185 if

(

auto

Res = CheckConditionalOperands(

false

); !Res.isNull())

3198 return

CheckConditionalOperands(

true

);

3209 for

(

auto T

: llvm::drop_begin(Ts)) {

3231 QualType

OrigType = Converted[1].getAsType();

3235

SemaRef.

(TemplateArgs[1].getLocation(),

3236

diag::err_integer_sequence_integral_element_type);

3251

OrigType, TemplateArgs[1].getLocation())));

3253 if

(llvm::APSInt NumArgs = NumArgsArg.

getAsIntegral

(); NumArgs >= 0) {

3255 for

(llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());

3259

TA, OrigType, TemplateArgs[2].getLocation()));

3264

SemaRef.

(TemplateArgs[2].getLocation(),

3265

diag::err_integer_sequence_negative_length);

3272

TemplateLoc, SyntheticTemplateArgs);

3279

assert(Converted.size() == 2 &&

3280 "__type_pack_element should be given an index and a parameter pack"

);

3288

assert(Index >= 0 &&

"the index used with __type_pack_element should be of " 3289 "type std::size_t, and hence be non-negative"

);

3291 if

(Index >= Ts.pack_size()) {

3292

SemaRef.

(TemplateArgs[0].getLocation(),

3293

diag::err_type_pack_element_out_of_bounds);

3298

int64_t N = Index.getExtValue();

3299 return

Ts.getPackAsArray()[N].getAsType();

3303

assert(Converted.size() == 4);

3304 if

(llvm::any_of(Converted, [](

auto

) {

return C

.isDependent(); }))

3308 TemplateName

BaseTemplate = Converted[0].getAsTemplate();

3309 TemplateName

HasTypeMember = Converted[1].getAsTemplate();

3310 QualType

HasNoTypeMember = Converted[2].getAsType();

3317

CT, TemplateArgs[1].getLocation())));

3321 return

HasNoTypeMember;

3324

llvm_unreachable(

"unexpected BuiltinTemplateDecl!"

);

3343 if

(BinOp->getOpcode() == BO_LAnd) {

3350

Terms.push_back(Clause);

3359 if

(!BinOp)

return

Cond;

3361 if

(BinOp->getOpcode() != BO_LOr)

return

Cond;

3364 Expr

*LHS = BinOp->getLHS();

3366 if

(!InnerBinOp)

return

Cond;

3368 if

(InnerBinOp->getOpcode() != BO_EQ ||

3369

!isa<IntegerLiteral>(InnerBinOp->getRHS()))

3379 if

(MacroName ==

"CONCEPT_REQUIRES"

|| MacroName ==

"CONCEPT_REQUIRES_"

)

3380 return

BinOp->getRHS();

3390class

FailedBooleanConditionPrinterHelper :

public PrinterHelper

{

3392 explicit

FailedBooleanConditionPrinterHelper(

const PrintingPolicy

)

3395 bool

handledStmt(

Stmt

, raw_ostream &OS)

override

{

3396 const auto

*DR = dyn_cast<DeclRefExpr>(

);

3397 if

(DR && DR->getQualifier()) {

3400

DR->getQualifier()->print(OS, Policy,

true

);

3404 if

(

const auto

*IV = dyn_cast<VarTemplateSpecializationDecl>(VD)) {

3407

OS, IV->getTemplateArgs().asArray(), Policy,

3408

IV->getSpecializedTemplate()->getTemplateParameters());

3421

std::pair<Expr *, std::string>

3430 Expr

*FailedCond =

nullptr

;

3431 for

(

Expr

*Term : Terms) {

3435 if

(isa<CXXBoolLiteralExpr>(TermAsWritten) ||

3436

isa<IntegerLiteral>(TermAsWritten))

3445 if

(Term->EvaluateAsBooleanCondition(Succeeded,

Context

) &&

3447

FailedCond = TermAsWritten;

3454

std::string Description;

3456

llvm::raw_string_ostream Out(Description);

3459

FailedBooleanConditionPrinterHelper Helper(Policy);

3460

FailedCond->

printPretty

(Out, &Helper, Policy, 0,

"\n"

nullptr

);

3462 return

{ FailedCond, Description };

3469

Name.getUnderlying().getAsDependentTemplateName();

3479 if

(Name.getAsAssumedTemplateName() &&

3483 auto

[Template, DefaultArgs] = Name.getTemplateDeclAndDefaultArgs();

3485 if

(!Template || isa<FunctionTemplateDecl>(Template) ||

3486

isa<VarTemplateDecl>(Template) || isa<ConceptDecl>(Template)) {

3489 if

(Name.getAsSubstTemplateTemplateParmPack())

3493 Diag

(TemplateLoc, diag::err_template_id_not_a_type)

3503

DefaultArgs,

false

3511

dyn_cast<TypeAliasTemplateDecl>(Template)) {

3527

().RetainSubstTemplateTypeParmTypeAstNodes);

3533

this

TemplateLoc,

3543

std::optional<ContextRAII> SavedContext;

3545

SavedContext.emplace(*

this

AliasTemplate

->getDeclContext());

3550 if

(CanonType.

()) {

3556 if

(*DeductionInfo &&

3557

(*DeductionInfo)->hasSFINAEDiagnostic() &&

3558

(*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==

3559

diag::err_typename_nested_not_found_enable_if &&

3560

TemplateArgs[0].getArgument().getKind()

3563

std::string FailedDescription;

3564

std::tie(FailedCond, FailedDescription) =

3570

(*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);

3574

(*DeductionInfo)->addSFINAEDiagnostic(

3576 PDiag

(diag::err_typename_nested_not_found_requirement)

3577

<< FailedDescription

3585

}

else if

(

auto

*BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {

3587

TemplateLoc, TemplateArgs);

3588

}

else if

(Name.isDependent() ||

3607 if

(isa<ClassTemplateDecl>(Template)) {

3610 if

(Ctx->isFileContext())

break

;

3614 if

)

continue

;

3618 if

(!isa<ClassTemplatePartialSpecializationDecl>(

) &&

3619

->getDescribedClassTemplate())

3625 QualType

Injected = cast<InjectedClassNameType>(ICNT)

3626

->getInjectedSpecializationType();

3639

dyn_cast<ClassTemplateDecl>(Template)) {

3642 void

*InsertPos =

nullptr

;

3676

assert(isa<RecordType>(CanonType) &&

3677 "type of non-dependent specialization is not a RecordType"

);

3679

llvm_unreachable(

"Unhandled template kind"

);

3696 auto

*ATN = Name.getAsAssumedTemplateName();

3697

assert(ATN &&

"not an assumed template name"

);

3698

II = ATN->getDeclName().getAsIdentifierInfo();

3714

assert(ATN &&

"not an assumed template name"

);

3722

std::unique_ptr<CorrectionCandidateCallback> clone()

override

{

3723 return

std::make_unique<CandidateCallback>(*

this

);

3749 bool

IsCtorOrDtorName,

bool

IsClassName,

3754 if

(!IsCtorOrDtorName && !IsClassName && SS.

()) {

3780

TemplateD, TemplateII, TemplateIILoc, LAngleLoc,

3781

TemplateArgsIn, RAngleLoc);

3788 auto

*LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);

3789 if

(LookupRD && LookupRD->getIdentifier() == TemplateII) {

3790 Diag

(TemplateIILoc,

3792

? diag::err_out_of_line_qualified_id_type_names_constructor

3793

: diag::ext_out_of_line_qualified_id_type_names_constructor)

3809

assert(SS.

() == DTN->getQualifier());

3823 for

(

unsigned

I = 0, N = SpecTL.

(); I != N; ++I)

3840 for

(

unsigned

i = 0, e = SpecTL.

(); i != e; ++i)

3879

assert(SS.

() == DTN->getQualifier());

3881

Keyword, DTN->getQualifier(), DTN->getIdentifier(),

3894 for

(

unsigned

I = 0, N = SpecTL.

(); I != N; ++I)

3905 Diag

(TemplateLoc, diag::err_tag_reference_non_tag)

3907 Diag

(TAT->getLocation(), diag::note_declared_at);

3919

assert(

"templated class must have an identifier"

);

3923 Diag

(TagLoc, diag::err_use_with_wrong_tag)

3938 for

(

unsigned

i = 0, e = SpecTL.

(); i != e; ++i)

3973 return

TPT && !

Type

.hasQualifiers() &&

3979 if

(!DRE || !DRE->

())

3982

dyn_cast<NonTypeTemplateParmDecl>(DRE->

());

3988

dyn_cast_or_null<TemplateTemplateParmDecl>(

3992

llvm_unreachable(

"unexpected kind of template argument"

);

3997 if

(Params->

() != Args.size())

4000 unsigned

Depth = Params->

();

4002 for

(

unsigned

I = 0, N = Args.size(); I != N; ++I) {

4021template

typename

PartialSpecDecl>

4023 if

(Partial->getDeclContext()->isDependentContext())

4032 auto

*Template = Partial->getSpecializedTemplate();

4033

(Partial->getLocation(),

4034

diag::ext_partial_spec_not_more_specialized_than_primary)

4035

<< isa<VarTemplateDecl>(Template);

4044

diag::note_partial_spec_not_more_specialized_than_primary)

4050

Template->getAssociatedConstraints(TemplateAC);

4051

Partial->getAssociatedConstraints(PartialAC);

4058 const

llvm::SmallBitVector &DeducibleParams) {

4059 for

(

unsigned

I = 0, N = DeducibleParams.size(); I != N; ++I) {

4060 if

(!DeducibleParams[I]) {

4073template

typename

PartialSpecDecl>

4075

PartialSpecDecl *Partial) {

4088 auto

*TemplateParams = Partial->getTemplateParameters();

4089

llvm::SmallBitVector DeducibleParams(TemplateParams->size());

4091

TemplateParams->getDepth(), DeducibleParams);

4093 if

(!DeducibleParams.all()) {

4094 unsigned

NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();

4095

(Partial->getLocation(), diag::ext_partial_specs_not_deducible)

4096

<< isa<VarTemplatePartialSpecializationDecl>(Partial)

4097

<< (NumNonDeducible > 1)

4099

Partial->getTemplateArgsAsWritten()->RAngleLoc);

4120

llvm::SmallBitVector DeducibleParams(TemplateParams->size());

4122 for

(

unsigned

I = 0; I != TemplateParams->size(); ++I) {

4124 auto

*Param = TemplateParams->getParam(I);

4126

DeducibleParams[I] =

true

;

4129 if

(!DeducibleParams.all()) {

4130 unsigned

NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();

4131 Diag

(TD->

(), diag::err_deduction_guide_template_not_deducible)

4132

<< (NumNonDeducible > 1);

4143 "Variable template specialization is declared with a template id."

);

4156

dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());

4159 if

(

auto

*OTS = Name.getAsOverloadedTemplate())

4160

FnTemplate = *OTS->begin();

4162

FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());

4164 return Diag

(

.getIdentifierLoc(), diag::err_var_spec_no_template_but_method)

4166 return Diag

(

.getIdentifierLoc(), diag::err_var_spec_no_template)

4170 if

(

const auto

*DSA =

VarTemplate

->getAttr<NoSpecializationsAttr>()) {

4171 auto

Message = DSA->getMessage();

4172 Diag

(TemplateNameLoc, diag::warn_invalid_specialization)

4174 Diag

(DSA->getLoc(), diag::note_marked_here) << DSA;

4178 for

(

unsigned

I = 0, N = TemplateArgs.

(); I != N; ++I)

4198

TemplateArgs.

(),

4204 if

(!Name.isDependent() &&

4207 Diag

(TemplateNameLoc, diag::err_partial_spec_fully_specialized)

4220 Diag

(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)

4230 void

*InsertPos =

nullptr

;

4234

PrevDecl =

VarTemplate

->findPartialSpecialization(

4256

PrevDecl =

nullptr

;

4260

cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);

4269 VarTemplate

->AddPartialSpecialization(Partial, InsertPos);

4308 Diag

(TemplateNameLoc, diag::err_specialization_after_instantiation)

4312

diag::note_instantiation_required_here)

4342struct

PartialSpecMatchResult {

4352

assert(Template &&

"A variable template id without template?"

);

4357

Template, TemplateNameLoc,

4371 void

*InsertPos =

nullptr

;

4385 bool

AmbiguousPartialSpec =

false

;

4411

!Partial->getMostRecentDecl()->isMemberSpecialization())

4426

Matched.push_back(PartialSpecMatchResult());

4427

Matched.back().Partial = Partial;

4432 if

(Matched.size() >= 1) {

4434 if

(Matched.size() == 1) {

4447

PEnd = Matched.end();

4450

PointOfInstantiation) ==

4458

PEnd = Matched.end();

4461 P

->Partial, Best->Partial,

4462

PointOfInstantiation) != Best->Partial) {

4463

AmbiguousPartialSpec =

true

;

4470

InstantiationPattern = Best->Partial;

4471

PartialSpecArgs = Best->Args;

4483

Template, InstantiationPattern, PartialSpecArgs, TemplateArgs,

4488 if

(AmbiguousPartialSpec) {

4491 Diag

(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)

4496 Diag

(

.Partial->getLocation(), diag::note_partial_spec_match)

4503

dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))

4504 Decl

->setInstantiationOf(

, PartialSpecArgs);

4508

assert(

"No variable template specialization?"

);

4519 if

(

.isInvalid())

4536 Diag

(

, diag::err_template_missing_args)

4544 bool

TemplateKeyword,

4559

assert(NamedConcept &&

"A concept template id without a template?"

);

4566

NamedConcept, ConceptNameInfo.

getLoc

(),

4579 bool

AreArgsDependent =

4589 if

(!AreArgsDependent &&

4599

TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,

4602 Context

, CL, CSD, AreArgsDependent ?

nullptr

: &Satisfaction);

4621

assert(!R.

isAmbiguous

() &&

"ambiguous lookup when building templateid"

);

4625 if

(!TemplateArgs && !isa<FunctionTemplateDecl>(TD)) {

4631 bool

KnownDependent =

false

;

4640

KnownDependent =

true

;

4655

(), R.

(), KnownDependent,

4672

assert(TemplateArgs || TemplateKWLoc.

());

4676 false

, TemplateKWLoc))

4687 Diag

(NameInfo.

getLoc

(), diag::err_no_member)

4705 bool

EnteringContext,

4707 bool

AllowInjectedClassName) {

4708 if

(TemplateKWLoc.

() && S && !S->getTemplateParamParent())

4709 Diag

(TemplateKWLoc,

4711

diag::warn_cxx98_compat_template_outside_of_template :

4712

diag::ext_template_outside_of_template)

4722 else if

(ObjectType)

4741 bool

MemberOfUnknownSpecialization;

4743

ObjectType, EnteringContext,

4744

MemberOfUnknownSpecialization);

4747 auto

*LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);

4748 if

(!AllowInjectedClassName && SS.

isNotEmpty

() && LookupRD &&

4750

Name.Identifier && LookupRD->getIdentifier() == Name.Identifier) {

4760 Diag

(Name.getBeginLoc(),

4761

diag::ext_out_of_line_qualified_id_type_names_constructor)

4769 if

(!MemberOfUnknownSpecialization) {

4783 nullptr

false

) &&

4786 Diag

(Name.getBeginLoc(), diag::err_no_member)

4789 Diag

(Name.getBeginLoc(), diag::err_undeclared_use)

4797 switch

(Name.getKind()) {

4805

Qualifier, Name.OperatorFunctionId.Operator));

4819 Diag

(Name.getBeginLoc(),

4820

diag::err_template_kw_refers_to_dependent_non_template)

4822

<< TemplateKWLoc.

() << TemplateKWLoc;

4859

dyn_cast<DependentScopeDeclRefExpr>(Arg.

getAsExpr

())) {

4860

SS.

(ArgExpr->getQualifierLoc());

4861

NameInfo = ArgExpr->getNameInfo();

4863

dyn_cast<CXXDependentScopeMemberExpr>(Arg.

getAsExpr

())) {

4864 if

(ArgExpr->isImplicitAccess()) {

4865

SS.

(ArgExpr->getQualifierLoc());

4866

NameInfo = ArgExpr->getMemberNameInfo();

4875 Result

.wasNotFoundInCurrentInstantiation()) {

4876

assert(SS.

() &&

"dependent scope expr must has a scope!"

);

4880

? diag::ext_ms_template_type_arg_missing_typename

4881

: diag::err_template_arg_must_be_type_suggest)

4913

SugaredConverted.push_back(Arg);

4914

CanonicalConverted.push_back(Arg);

4920 Diag

(SR.

(), diag::err_template_arg_must_be_type) << SR;

4942

CanonicalConverted.push_back(

4991 for

(

unsigned

i = 0, e = Param->

(); i != e; ++i)

4994 bool

ForLambdaCallOperator =

false

;

4995 if

(

const auto

*Rec = dyn_cast<CXXRecordDecl>(Template->

getDeclContext

()))

4996

ForLambdaCallOperator = Rec->isLambda();

4998

!ForLambdaCallOperator);

5046 for

(

unsigned

i = 0, e = Param->

(); i != e; ++i)

5053

TemplateArgLists, Output);

5089

SugaredConverted,

SourceRange

(TemplateLoc, RAngleLoc));

5096 for

(

unsigned

i = 0, e = Param->

(); i != e; ++i)

5121

HasDefaultArg =

false

;

5127

HasDefaultArg =

true

;

5130

TypeParm, SugaredConverted,

5131

CanonicalConverted, Output))

5137

= dyn_cast<NonTypeTemplateParmDecl>(Param)) {

5141

HasDefaultArg =

true

;

5144

NonTypeParm, SugaredConverted,

5145

CanonicalConverted, Output))

5151

= cast<TemplateTemplateParmDecl>(Param);

5155

HasDefaultArg =

true

;

5158

this

, Template, TemplateLoc, RAngleLoc, TempTempParm, SugaredConverted,

5159

CanonicalConverted, QualifierLoc);

5180

QualLoc = ETLoc.getQualifierLoc();

5181

TLoc = ETLoc.getNamedTypeLoc();

5187

QualLoc, InjLoc.getNameLoc());

5195

dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))

5198

QualLoc, RecLoc.getNameLoc());

5207 unsigned

ArgumentPackIndex,

5221 QualType

NTTPType = NTTP->getType();

5222 if

(NTTP->isParameterPack() && NTTP->isExpandedParameterPack())

5223

NTTPType = NTTP->getExpansionType(ArgumentPackIndex);

5226

!isa<TemplateTemplateParmDecl>(Template) &&

5241

NTTPType =

SubstType

(PET->getPattern(), MLTAL, NTTP->getLocation(),

5242

NTTP->getDeclName());

5244

NTTPType =

SubstType

(NTTPType, MLTAL, NTTP->getLocation(),

5245

NTTP->getDeclName());

5250 if

(!NTTPType.

())

5252

NTTP->getLocation());

5257 auto

checkExpr = [&](

Expr

) ->

Expr

* {

5273

llvm_unreachable(

"Should never see a NULL template argument here"

);

5277 Expr

*R = checkExpr(

);

5303 if

(!checkExpr(R.

()))

5336 if

(

.isInvalid())

5342

CanonicalResult,

false

5344 if

(

.isInvalid())

5375 Diag

(SR.

(), diag::err_template_arg_nontype_ambig) << SR <<

;

5377 Diag

(SR.

(), diag::err_template_arg_must_be_expr) << SR;

5383

llvm_unreachable(

"Caller must expand template argument packs"

);

5428

ArgLoc = ConvertedArg;

5433

llvm_unreachable(

"Should never see a NULL template argument here"

);

5451 Diag

(ArgLoc.

(), diag::err_template_arg_must_be_template)

5459

llvm_unreachable(

"non-type argument with template template parameter"

);

5462

llvm_unreachable(

"Caller must expand template argument packs"

);

5469template

typename

TemplateParmDecl>

5472 const

TemplateParmDecl *

5477

->getTemplateParameters()

5478

->getParam(

->getIndex()));

5485 D

->getDefaultArgumentLoc(), Modules,

5496

(

, diag::err_template_arg_list_different_arity)

5529 bool

isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);

5532 unsigned

ArgIdx = 0, NumArgs = NewArgs.

();

5535

ParamEnd = Params->

(),

5539 if

(

size_t ParamIdx

= Param - ParamBegin;

5542

assert(ArgIdx == NumArgs &&

"bad default argument deduction"

);

5544

assert(Param + DefaultArgs.

Args

.size() <= ParamEnd);

5559 if

(*Expansions == SugaredArgumentPack.size()) {

5564

SugaredArgumentPack.clear();

5568

CanonicalArgumentPack.clear();

5573

}

else if

(ArgIdx == NumArgs && !PartialTemplateArgs) {

5575 Diag

(TemplateLoc, diag::err_template_arg_list_different_arity)

5584 if

(ArgIdx < NumArgs) {

5586 bool

NonPackParameter =

5596 if

(!(*Param)->isTemplateParameterPack() ||

5603

RAngleLoc, SugaredArgumentPack.size(), CTAI,

5618

RAngleLoc, SugaredArgumentPack.size(), CTAI,

5625 if

(ArgIsExpansion && NonPackParameter) {

5629 if

(isa<TypeAliasTemplateDecl, ConceptDecl>(Template)) {

5631

diag::err_template_expansion_into_fixed_list)

5632

<< (isa<ConceptDecl>(Template) ? 1 : 0)

5643 if

(ArgIsExpansion && (CTAI.

MatchingTTP

|| NonPackParameter)) {

5647 if

(!SugaredArgumentPack.empty()) {

5651

SugaredArgumentPack.begin(),

5652

SugaredArgumentPack.end());

5653

SugaredArgumentPack.clear();

5656

CanonicalArgumentPack.begin(),

5657

CanonicalArgumentPack.end());

5658

CanonicalArgumentPack.clear();

5661 while

(ArgIdx < NumArgs) {

5672 if

((*Param)->isTemplateParameterPack()) {

5687 if

(PartialTemplateArgs) {

5688 if

((*Param)->isTemplateParameterPack() && !SugaredArgumentPack.empty()) {

5699 if

((*Param)->isTemplateParameterPack()) {

5701 "Should have dealt with this already"

);

5706 if

(Param + 1 != ParamEnd) {

5709 "Concept templates must have parameter packs at the end."

);

5715

SugaredArgumentPack.clear();

5719

CanonicalArgumentPack.clear();

5738 if

(!HasDefaultArg) {

5743

dyn_cast<NonTypeTemplateParmDecl>(*Param))

5747

cast<TemplateTemplateParmDecl>(*Param),

5777 if

(isTemplateTemplateParameter)

5792 while

(ArgIdx < NumArgs &&

5793

NewArgs[ArgIdx].

getArgument

().isPackExpansion()) {

5803 if

(ArgIdx < NumArgs) {

5804 Diag

(TemplateLoc, diag::err_template_arg_list_different_arity)

5815 if

(UpdateArgsWithConversions)

5816

TemplateArgs = std::move(NewArgs);

5818 if

(!PartialTemplateArgs) {

5825 if

(

auto

*TD = dyn_cast<TemplateDecl>(NewContext))

5827 auto

*RD = dyn_cast<CXXRecordDecl>(NewContext);

5830 if

(

const auto

*Method =

5832

ThisQuals = Method->getMethodQualifiers();

5855 class

UnnamedLocalNoLinkageFinder

5856

public TypeVisitor

<UnnamedLocalNoLinkageFinder, bool>

5864

UnnamedLocalNoLinkageFinder(

&S,

SourceRange

SR) : S(S), SR(SR) { }

5867 return T

.isNull() ?

false

: inherited::Visit(

.getTypePtr());

5870#define TYPE(Class, Parent) \ 5871 bool Visit##Class##Type(const Class##Type *); 5872#define ABSTRACT_TYPE(Class, Parent) \ 5873 bool Visit##Class##Type(const Class##Type *) { return false; } 5874#define NON_CANONICAL_TYPE(Class, Parent) \ 5875 bool Visit##Class##Type(const Class##Type *) { return false; } 5876#include "clang/AST/TypeNodes.inc" 5878 bool

VisitTagDecl(

const TagDecl

*Tag);

5883bool

UnnamedLocalNoLinkageFinder::VisitBuiltinType(

const BuiltinType

*) {

5887bool

UnnamedLocalNoLinkageFinder::VisitComplexType(

const ComplexType

) {

5888 return

Visit(

->getElementType());

5891bool

UnnamedLocalNoLinkageFinder::VisitPointerType(

const PointerType

) {

5895bool

UnnamedLocalNoLinkageFinder::VisitBlockPointerType(

5900bool

UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(

5905bool

UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(

5910bool

UnnamedLocalNoLinkageFinder::VisitMemberPointerType(

5915bool

UnnamedLocalNoLinkageFinder::VisitConstantArrayType(

5917 return

Visit(

->getElementType());

5920bool

UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(

5922 return

Visit(

->getElementType());

5925bool

UnnamedLocalNoLinkageFinder::VisitVariableArrayType(

5927 return

Visit(

->getElementType());

5930bool

UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(

5932 return

Visit(

->getElementType());

5935bool

UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(

5937 return

Visit(

->getElementType());

5940bool

UnnamedLocalNoLinkageFinder::VisitDependentSizedMatrixType(

5942 return

Visit(

->getElementType());

5945bool

UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(

5950bool

UnnamedLocalNoLinkageFinder::VisitVectorType(

const VectorType

) {

5951 return

Visit(

->getElementType());

5954bool

UnnamedLocalNoLinkageFinder::VisitDependentVectorType(

5956 return

Visit(

->getElementType());

5959bool

UnnamedLocalNoLinkageFinder::VisitExtVectorType(

const ExtVectorType

) {

5960 return

Visit(

->getElementType());

5963bool

UnnamedLocalNoLinkageFinder::VisitConstantMatrixType(

5965 return

Visit(

->getElementType());

5968bool

UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(

5978bool

UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(

5983bool

UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(

5988bool

UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(

const TypeOfExprType

*) {

5992bool

UnnamedLocalNoLinkageFinder::VisitTypeOfType(

const TypeOfType

) {

5993 return

Visit(

->getUnmodifiedType());

5996bool

UnnamedLocalNoLinkageFinder::VisitDecltypeType(

const DecltypeType

*) {

6000bool

UnnamedLocalNoLinkageFinder::VisitPackIndexingType(

6005bool

UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(

6010bool

UnnamedLocalNoLinkageFinder::VisitAutoType(

const AutoType

) {

6011 return

Visit(

->getDeducedType());

6014bool

UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(

6016 return

Visit(

->getDeducedType());

6019bool

UnnamedLocalNoLinkageFinder::VisitRecordType(

const RecordType

) {

6020 return

VisitTagDecl(

->getDecl());

6023bool

UnnamedLocalNoLinkageFinder::VisitEnumType(

const EnumType

) {

6024 return

VisitTagDecl(

->getDecl());

6027bool

UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(

6032bool

UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(

6037bool

UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(

6042bool

UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(

6044 return

VisitTagDecl(

->getDecl());

6047bool

UnnamedLocalNoLinkageFinder::VisitDependentNameType(

6049 return

VisitNestedNameSpecifier(

->getQualifier());

6052bool

UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(

6054 if

(

auto

*Q =

->getQualifier())

6055 return

VisitNestedNameSpecifier(Q);

6059bool

UnnamedLocalNoLinkageFinder::VisitPackExpansionType(

6061 return

Visit(

->getPattern());

6064bool

UnnamedLocalNoLinkageFinder::VisitObjCObjectType(

const ObjCObjectType

*) {

6068bool

UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(

6073bool

UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(

6078bool

UnnamedLocalNoLinkageFinder::VisitAtomicType(

const AtomicType

) {

6079 return

Visit(

->getValueType());

6082bool

UnnamedLocalNoLinkageFinder::VisitPipeType(

const PipeType

) {

6086bool

UnnamedLocalNoLinkageFinder::VisitBitIntType(

const BitIntType

) {

6090bool

UnnamedLocalNoLinkageFinder::VisitArrayParameterType(

6092 return

VisitConstantArrayType(

);

6095bool

UnnamedLocalNoLinkageFinder::VisitDependentBitIntType(

6100bool

UnnamedLocalNoLinkageFinder::VisitTagDecl(

const TagDecl

*Tag) {

6101 if

(

Tag

->getDeclContext()->isFunctionOrMethod()) {

6102

(SR.getBegin(),

6104

diag::warn_cxx98_compat_template_arg_local_type :

6105

diag::ext_template_arg_local_type)

6110 if

Tag

->hasNameForLinkage()) {

6111

(SR.getBegin(),

6113

diag::warn_cxx98_compat_template_arg_unnamed_type :

6114

diag::ext_template_arg_unnamed_type) << SR;

6115

(

Tag

->getLocation(), diag::note_template_unnamed_type_here);

6122bool

UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(

6140

llvm_unreachable(

"Invalid NestedNameSpecifier::Kind!"

);

6143bool

UnnamedLocalNoLinkageFinder::VisitHLSLAttributedResourceType(

6145 if

(

->hasContainedType() && Visit(

->getContainedType()))

6147 return

Visit(

->getWrappedType());

6151

assert(ArgInfo &&

"invalid TypeSourceInfo"

);

6157 return Diag

(SR.

(), diag::err_variably_modified_template_arg) << Arg;

6159 return Diag

(SR.

(), diag::err_template_arg_overload_type) << SR;

6170

UnnamedLocalNoLinkageFinder Finder(*

this

, SR);

6171

(void)Finder.Visit(CanonArg);

6188 Decl

*Entity =

nullptr

) {

6194 if

(Entity && Entity->hasAttr<DLLImportAttr>())

6199 "Incomplete parameter type in isNullPointerValueTemplateArgument!"

);

6208

Arg = ArgRV.

();

6212

EvalResult.

= &Notes;

6220 if

(Notes.size() == 1 && Notes[0].second.getDiagID() ==

6221

diag::note_invalid_subexpr_in_const_expr) {

6222

DiagLoc = Notes[0].first;

6226

(DiagLoc, diag::err_template_arg_not_address_constant)

6228 for

(

unsigned

I = 0, N = Notes.size(); I != N; ++I)

6229

(Notes[I].first, Notes[I].second);

6247 bool

ObjCLifetimeConversion;

6250

ObjCLifetimeConversion))

6255

(Arg->

(), diag::err_template_arg_wrongtype_null_constant)

6274

std::string Code =

"static_cast<"

+ ParamType.

getAsString

() +

">("

;

6275

(Arg->

(), diag::err_template_arg_untyped_null_constant)

6294 bool

ObjCLifetimeConversion;

6298

ObjCLifetimeConversion)) {

6303 if

(!ParamRef->getPointeeType()->isFunctionType()) {

6313 unsigned

ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();

6316 if

((ParamQuals | ArgQuals) != ParamQuals) {

6318

diag::err_template_arg_ref_bind_ignores_quals)

6336

(Arg->

(), diag::err_template_arg_not_convertible)

6355 bool

AddressTaken =

false

;

6362 bool

ExtWarnMSTemplateArg =

false

;

6365 while

(

UnaryOperator

*UnOp = dyn_cast<UnaryOperator>(Arg)) {

6367 if

(UnOpKind == UO_Deref)

6368

ExtWarnMSTemplateArg =

true

;

6369 if

(UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {

6372

FirstOpKind = UnOpKind;

6373

FirstOpLoc = UnOp->getOperatorLoc();

6379 if

(ExtWarnMSTemplateArg)

6380

(ArgIn->

(), diag::ext_ms_deref_template_argument)

6383 if

(FirstOpKind == UO_AddrOf)

6384

AddressTaken =

true

;

6388

assert(FirstOpKind == UO_Deref);

6411 bool

ExtraParens =

false

;

6413 if

Invalid

&& !ExtraParens) {

6416

? diag::warn_cxx98_compat_template_arg_extra_parens

6417

: diag::ext_template_arg_extra_parens)

6419

ExtraParens =

true

;

6422

Arg =

Parens

->getSubExpr();

6426

dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))

6430 if

(UnOp->getOpcode() == UO_AddrOf) {

6431

Arg = UnOp->getSubExpr();

6432

AddressTaken =

true

;

6433

AddrOpLoc = UnOp->getOperatorLoc();

6438

dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))

6443 if

(

DeclRefExpr

*DRE = dyn_cast<DeclRefExpr>(Arg))

6444

Entity = DRE->getDecl();

6445 else if

(

CXXUuidofExpr

*CUE = dyn_cast<CXXUuidofExpr>(Arg))

6446

Entity = CUE->getGuidDecl();

6453

(Arg->

(), diag::warn_cxx98_compat_template_arg_null);

6456

CanonicalConverted =

6473

CanonicalConverted =

6486 if

(isa<FieldDecl>(Entity) || isa<IndirectFieldDecl>(Entity)) {

6494 if

(

CXXMethodDecl

*Method = dyn_cast<CXXMethodDecl>(Entity)) {

6495 if

(!Method->isStatic()) {

6504 VarDecl

*Var = dyn_cast<VarDecl>(Entity);

6505 MSGuidDecl

*Guid = dyn_cast<MSGuidDecl>(Entity);

6508 if

Func

&& !Var && !Guid) {

6510

(Arg->

(), diag::err_template_arg_not_object_or_func)

6512

(Entity->

(), diag::note_template_arg_refers_here);

6520

? diag::warn_cxx98_compat_template_arg_object_internal

6521

: diag::ext_template_arg_object_internal)

6523

(Entity->

(), diag::note_template_arg_internal_object)

6526

(Arg->

(), diag::err_template_arg_object_no_linkage)

6528

(Entity->

(), diag::note_template_arg_internal_object)

6557

(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)

6563

(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)

6568

ArgType = Entity->

getType

();

6605

CanonicalConverted =

6621 Expr

*Arg = ResultArg;

6622 bool

ObjCLifetimeConversion;

6634 bool

ExtraParens =

false

;

6636 if

Invalid

&& !ExtraParens) {

6639

? diag::warn_cxx98_compat_template_arg_extra_parens

6640

: diag::ext_template_arg_extra_parens)

6642

ExtraParens =

true

;

6645

Arg =

Parens

->getSubExpr();

6649

dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))

6654 if

(UnOp->getOpcode() == UO_AddrOf) {

6655

DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());

6661 else if

((DRE = dyn_cast<DeclRefExpr>(Arg))) {

6664 if

(isa<NonTypeTemplateParmDecl>(VD)) {

6667

CanonicalConverted =

6671

CanonicalConverted =

6690

(ResultArg->

(), diag::warn_cxx98_compat_template_arg_null);

6702

ObjCLifetimeConversion)) {

6709

(ResultArg->

(), diag::err_template_arg_not_convertible)

6717

diag::err_template_arg_not_pointer_to_member_form)

6720 if

(isa<FieldDecl>(DRE->

()) ||

6721

isa<IndirectFieldDecl>(DRE->

()) ||

6722

isa<CXXMethodDecl>(DRE->

())) {

6723

assert((isa<FieldDecl>(DRE->

()) ||

6724

isa<IndirectFieldDecl>(DRE->

()) ||

6725

cast<CXXMethodDecl>(DRE->

())

6726

->isImplicitObjectMemberFunction()) &&

6727 "Only non-static member pointers can make it here"

);

6733

CanonicalConverted =

6738

CanonicalConverted =

6746

(Arg->

(), diag::err_template_arg_not_pointer_to_member_form)

6756 bool

PartialOrderingTTP,

6769 auto

*AT = dyn_cast<AutoType>(DeducedT);

6770 if

(AT && AT->isDecltypeAuto()) {

6781 Expr

*DeductionArg = Arg;

6782 if

(

auto

*PE = dyn_cast<PackExpansionExpr>(DeductionArg))

6783

DeductionArg = PE->getPattern();

6786 if

(isa<DeducedTemplateSpecializationType>(DeducedT)) {

6790

DeductionArg->

(),

false

, DeductionArg);

6791 Expr

*Inits[1] = {DeductionArg};

6794 if

(ParamType.

())

6810 if

(ParamType.

())

6814

diag::err_non_type_template_parm_type_deduction_failure)

6826 if

(ParamType.

()) {

6834 "non-type template parameter type cannot be qualified"

);

6860 Diag

(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)

6871 auto

*PE = dyn_cast<PackExpansionExpr>(Arg);

6873

Arg = PE->getPattern();

6879 if

(

.isInvalid())

6885

PE->getNumExpansions());

6903 if

(ParamType->

isRecordType

() && isa<DeclRefExpr>(InnerArg) &&

6905 NamedDecl

*ND = cast<DeclRefExpr>(InnerArg)->getDecl();

6906 if

(

auto

*TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {

6909

CanonicalConverted =

6913 if

(isa<NonTypeTemplateParmDecl>(ND)) {

6915

CanonicalConverted =

6926 bool

IsConvertedConstantExpression =

true

;

6927 if

(isa<InitListExpr>(Arg) || ParamType->

isRecordType

()) {

6930 Expr

*Inits[1] = {Arg};

6944

IsConvertedConstantExpression =

false

;

6953 if

(IsConvertedConstantExpression) {

6957

assert(!ArgResult.

isUnset

());

6970

CanonicalConverted =

6978 false

, PreNarrowingValue);

6982 if

(

.isLValue()) {

6995

isa<LifetimeExtendedTemporaryDecl, UnnamedGlobalConstantDecl>(VD))) {

7001 if

(

.hasLValuePath() &&

.getLValuePath().size() == 1 && VD &&

7003 Value

.getLValuePath()[0].getAsArrayIndex() == 0 &&

7008 return

ArgResult.

();

7013 if

.hasLValuePath() ||

.getLValuePath().size() ||

7014 Value

.isLValueOnePastTheEnd()) {

7015 Diag

(StartLoc, diag::err_non_type_template_arg_subobject)

7020 "null reference should not be a constant expression"

);

7022 "non-null value of type nullptr_t?"

);

7026 if

(

.isAddrLabelDiff())

7027 return Diag

(StartLoc, diag::err_non_type_template_arg_addr_label_diff);

7031 return

ArgResult.

();

7059

llvm::APSInt

;

7069

CanonicalConverted =

7079

IntegerType =

Enum

->getDecl()->getIntegerType();

7085

CanonicalConverted =

7093

Arg = ArgResult.

();

7104

llvm::APSInt

;

7106 Diag

(Arg->

(), diag::err_template_arg_not_integral_or_enumeral)

7119 return

(

, diag::err_template_arg_not_ice) <<

;

7121

} Diagnoser(ArgType);

7157

CanonicalConverted =

7164

IntegerType =

Enum

->getDecl()->getIntegerType();

7171 if

(

.getBitWidth() != AllowedBits)

7175

llvm::APSInt OldValue =

;

7182 if

(

.getBitWidth() != AllowedBits)

7188

(OldValue.isSigned() && OldValue.isNegative())) {

7196 unsigned

RequiredBits;

7198

RequiredBits = OldValue.getActiveBits();

7199 else if

(OldValue.isUnsigned())

7200

RequiredBits = OldValue.getActiveBits() + 1;

7202

RequiredBits = OldValue.getSignificantBits();

7203 if

(RequiredBits > AllowedBits) {

7213

CanonicalConverted =

7263

this

, Param, ParamType, Arg, SugaredConverted,

7264

CanonicalConverted))

7270

this

, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))

7281 "Only object pointers allowed here"

);

7284

this

, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))

7296

assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&

7297 "Only object references allowed here"

);

7301

ParamRefType->getPointeeType(),

7316

this

, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))

7325

CanonicalConverted =

7332 Diag

(Arg->

(), diag::err_template_arg_not_convertible)

7333

<< Arg->

getType

() << ParamType;

7341 Diag

(Arg->

(), diag::warn_cxx98_compat_template_arg_null);

7355

this

, Param, ParamType, Arg, SugaredConverted, CanonicalConverted))

7367 bool

*MatchedPackOnParmToNonPackOnArg) {

7369 auto

[Template, DefaultArgs] = Name.getTemplateDeclAndDefaultArgs();

7372

assert(Name.isDependent() &&

"Non-dependent template isn't a declaration?"

);

7376 if

(Template->isInvalidDecl())

7391 if

(!isa<ClassTemplateDecl>(Template) &&

7392

!isa<TemplateTemplateParmDecl>(Template) &&

7393

!isa<TypeAliasTemplateDecl>(Template) &&

7394

!isa<BuiltinTemplateDecl>(Template)) {

7395

assert(isa<FunctionTemplateDecl>(Template) &&

7396 "Only function templates are possible here"

);

7397 Diag

(Arg.

(), diag::err_template_arg_not_valid_template);

7398 Diag

(Template->getLocation(), diag::note_template_arg_refers_here_func)

7406

Params, Param, Template, DefaultArgs, Arg.

(),

7418 if

(ParamsAC.empty())

7421

Template->getAssociatedConstraints(TemplateAC);

7423 bool

IsParamAtLeastAsConstrained;

7425

IsParamAtLeastAsConstrained))

7427 if

(!IsParamAtLeastAsConstrained) {

7429

diag::err_template_template_parameter_not_at_least_as_constrained)

7431 Diag

(Param->

(), diag::note_entity_declared_at) << Param;

7432 Diag

(Template->getLocation(), diag::note_entity_declared_at) << Template;

7441 unsigned

HereDiagID,

7442 unsigned

ExternalDiagID) {

7447

llvm::raw_svector_ostream Out(Str);

7455

std::optional<SourceRange> ParamRange) {

7458

diag::note_template_decl_external);

7459 if

(ParamRange && ParamRange->isValid()) {

7461 "Parameter range has location when Decl does not"

);

7468

diag::note_template_param_external);

7491

? CK_NullToMemberPointer

7492

: CK_NullToPointer);

7495 "Only declaration template arguments permitted here"

);

7504

(isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||

7505

isa<IndirectFieldDecl>(VD)));

7533

assert(isa<TemplateParamObjectDecl>(VD) &&

7534 "arg for class template param not a template parameter object"

);

7539 "unexpected type for decl template argument"

);

7541

dyn_cast_if_present<NonTypeTemplateParmDecl>(

TemplateParam

)) {

7542 QualType

TemplateParamType = NTTP->getType();

7556 "value kind mismatch for non-type template argument"

);

7576 "unexpected conversion required for non-type template argument"

);

7603 T

= ET->getDecl()->getIntegerType();

7654

llvm_unreachable(

"unexpected template argument value"

);

7679 return

MakeInitList(

7692 return

MakeInitList(Elts);

7697

llvm_unreachable(

"Unexpected APValue kind."

);

7713

llvm_unreachable(

"Unhandled APValue::ValueKind enum"

);

7725

llvm_unreachable(

"not a non-type template argument"

);

7743

llvm_unreachable(

"Unhandled TemplateArgument::ArgKind enum"

);

7750 const NamedDecl

*OldInstFrom,

bool

Complain,

7755 unsigned

NextDiag = diag::err_template_param_different_kind;

7756 if

(TemplateArgLoc.

()) {

7757

(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);

7758

NextDiag = diag::note_template_param_different_kind;

7775 unsigned

NextDiag = diag::err_template_parameter_pack_non_pack;

7776 if

(TemplateArgLoc.

()) {

7777

(TemplateArgLoc,

7778

diag::err_template_arg_template_params_mismatch);

7779

NextDiag = diag::note_template_parameter_pack_non_pack;

7782 unsigned

ParamKind = isa<TemplateTypeParmDecl>(New)? 0

7783

: isa<NonTypeTemplateParmDecl>(New)? 1

7787

(Old->

(), diag::note_template_parameter_pack_here)

7796

= dyn_cast<NonTypeTemplateParmDecl>(Old)) {

7807 unsigned

NextDiag = diag::err_template_nontype_parm_different_type;

7808 if

(TemplateArgLoc.

()) {

7809

(TemplateArgLoc,

7810

diag::err_template_arg_template_params_mismatch);

7811

NextDiag = diag::note_template_nontype_parm_different_type;

7815

(OldNTTP->getLocation(),

7816

diag::note_template_nontype_parm_prev_declaration)

7817

<< OldNTTP->getType();

7827

dyn_cast<TemplateTemplateParmDecl>(Old)) {

7831

OldTTP->getTemplateParameters(), Complain,

7840

!isa<TemplateTemplateParmDecl>(Old)) {

7841 const Expr

*NewC =

nullptr

, *OldC =

nullptr

;

7843 if

(isa<TemplateTypeParmDecl>(New)) {

7844 if

(

const auto

*TC = cast<TemplateTypeParmDecl>(New)->getTypeConstraint())

7845

NewC = TC->getImmediatelyDeclaredConstraint();

7846 if

(

const auto

*TC = cast<TemplateTypeParmDecl>(Old)->getTypeConstraint())

7847

OldC = TC->getImmediatelyDeclaredConstraint();

7848

}

else if

(isa<NonTypeTemplateParmDecl>(New)) {

7849 if

(

const Expr

= cast<NonTypeTemplateParmDecl>(New)

7850

->getPlaceholderTypeConstraint())

7852 if

(

const Expr

= cast<NonTypeTemplateParmDecl>(Old)

7853

->getPlaceholderTypeConstraint())

7856

llvm_unreachable(

"unexpected template parameter type"

);

7858 auto

Diagnose = [&] {

7860

diag::err_template_different_type_constraint);

7862

diag::note_template_prev_declaration) <<

7865 if

(!NewC != !OldC) {

7892 unsigned

NextDiag = diag::err_template_param_list_different_arity;

7893 if

(TemplateArgLoc.

()) {

7894

(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);

7895

NextDiag = diag::note_template_param_list_different_arity;

7910 if

(Old->

() != New->

()) {

7927

OldParmEnd = Old->

();

7928

OldParm != OldParmEnd; ++OldParm, ++NewParm) {

7929 if

(NewParm == NewParmEnd) {

7936

OldInstFrom, Complain, Kind,

7942 if

(NewParm != NewParmEnd) {

7956

diag::err_template_different_requires_clause);

7958

diag::note_template_prev_declaration) <<

7961 if

(!NewRC != !OldRC) {

7986

S = S->getDeclParent();

7992 if

(Ctx && Ctx->isExternCContext()) {

7996 Diag

(LSD->getExternLoc(), diag::note_extern_c_begins_here);

7999

Ctx = Ctx ? Ctx->getRedeclContext() :

nullptr

;

8011 if

(Ctx->isFileContext())

8016 if

(RD->isLocalClass())

8018

diag::err_template_inside_local_class)

8026

diag::err_template_outside_namespace_or_class_scope)

8037 return Record

->getTemplateSpecializationKind();

8039 return Function

->getTemplateSpecializationKind();

8040 if

(

VarDecl

*Var = dyn_cast<VarDecl>(

))

8041 return

Var->getTemplateSpecializationKind();

8078 if

(isa<ClassTemplateDecl>(Specialized))

8080 else if

(isa<VarTemplateDecl>(Specialized))

8082 else if

(isa<FunctionTemplateDecl>(Specialized))

8084 else if

(isa<CXXMethodDecl>(Specialized))

8086 else if

(isa<VarDecl>(Specialized))

8088 else if

(isa<RecordDecl>(Specialized))

8090 else if

(isa<EnumDecl>(Specialized) && S.

().CPlusPlus11)

8093

(

, diag::err_template_spec_unknown_kind)

8095

(Specialized->

(), diag::note_specialized_entity);

8103

(

, diag::err_template_spec_decl_function_scope)

8118

: DC->

Equals

(SpecializedContext))) {

8119 if

(isa<TranslationUnitDecl>(SpecializedContext))

8120

(

, diag::err_template_spec_redecl_global_scope)

8121

<< EntityKind << Specialized;

8123 auto

*ND = cast<NamedDecl>(SpecializedContext);

8124 int Diag

= diag::err_template_spec_redecl_out_of_scope;

8126 Diag

= diag::ext_ms_template_spec_redecl_out_of_scope;

8127

(

) << EntityKind << Specialized

8128

<< ND << isa<CXXRecordDecl>(ND);

8131

(Specialized->getLocation(), diag::note_specialized_entity);

8145

DependencyChecker Checker(Depth,

true

);

8146

Checker.TraverseStmt(

);

8147 if

(Checker.MatchLoc.isInvalid())

8149 return

Checker.MatchLoc;

8155

DependencyChecker Checker(Depth,

true

);

8156

Checker.TraverseTypeLoc(TL);

8157 if

(Checker.MatchLoc.isInvalid())

8159 return

Checker.MatchLoc;

8167 for

(

unsigned

I = 0; I != NumArgs; ++I) {

8170

S, TemplateNameLoc, Param, Args[I].pack_begin(),

8171

Args[I].pack_size(), IsDefaultArgument))

8184

ArgExpr = Expansion->getPattern();

8188

ArgExpr = ICE->getSubExpr();

8198 if

(

DeclRefExpr

*DRE = dyn_cast<DeclRefExpr>(ArgExpr))

8199 if

(isa<NonTypeTemplateParmDecl>(DRE->getDecl()))

8219 if

(ParamUseRange.

()) {

8220 if

(IsDefaultArgument) {

8221

(TemplateNameLoc,

8222

diag::err_dependent_non_type_arg_in_partial_spec);

8224

diag::note_dependent_non_type_default_arg_in_partial_spec)

8228

diag::err_dependent_non_type_arg_in_partial_spec)

8236 if

(ParamUseRange.

()) {

8237

(IsDefaultArgument ? TemplateNameLoc : ArgExpr->

(),

8238

diag::err_dependent_typed_non_type_arg_in_partial_spec)

8258 for

(

unsigned

I = 0, N = TemplateParams->

(); I != N; ++I) {

8260

= dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->

getParam

(I));

8265

Param, &TemplateArgs[I],

8266

1, I >= NumExplicit))

8287

= dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());

8290 Diag

(TemplateNameLoc, diag::err_not_class_template_specialization)

8291

<< (Name.getAsTemplateDecl() &&

8292

isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));

8296 if

(

const auto

*DSA =

ClassTemplate

->getAttr<NoSpecializationsAttr>()) {

8297 auto

Message = DSA->getMessage();

8298 Diag

(TemplateNameLoc, diag::warn_invalid_specialization)

8300 Diag

(DSA->getLoc(), diag::note_marked_here) << DSA;

8303 if

(S->isTemplateParamScope())

8308 bool

isMemberSpecialization =

false

;

8309 bool

isPartialSpecialization =

false

;

8314

TemplateNameLoc, &TemplateId,

8326

KWLoc, TemplateNameLoc, SS, &TemplateId, TemplateParameterLists,

8341 if

(TemplateParams && TemplateParams->

() > 0) {

8342

isPartialSpecialization =

true

;

8345 Diag

(KWLoc, diag::err_partial_specialization_friend)

8353 for

(

unsigned

I = 0, N = TemplateParams->

(); I != N; ++I) {

8356 if

(TTP->hasDefaultArgument()) {

8357 Diag

(TTP->getDefaultArgumentLoc(),

8358

diag::err_default_arg_in_partial_spec);

8359

TTP->removeDefaultArgument();

8362

= dyn_cast<NonTypeTemplateParmDecl>(Param)) {

8363 if

(NTTP->hasDefaultArgument()) {

8364 Diag

(NTTP->getDefaultArgumentLoc(),

8365

diag::err_default_arg_in_partial_spec)

8366

<< NTTP->getDefaultArgument().getSourceRange();

8367

NTTP->removeDefaultArgument();

8373

diag::err_default_arg_in_partial_spec)

8379

}

else if

(TemplateParams) {

8381 Diag

(KWLoc, diag::err_template_spec_friend)

8388 "should have a 'template<>' for this decl"

);

8395 "Invalid enum tag in class template spec!"

);

8399 Diag

(KWLoc, diag::err_use_with_wrong_tag)

8404

diag::note_previous_use);

8413 for

(

unsigned

I = 0, N = TemplateArgs.

(); I != N; ++I)

8415

isPartialSpecialization

8431 if

(isPartialSpecialization) {

8433

TemplateArgs.

(),

8439 if

(!Name.isDependent() &&

8442 Diag

(TemplateNameLoc, diag::err_partial_spec_fully_specialized)

8444

isPartialSpecialization =

false

;

8449 void

*InsertPos =

nullptr

;

8452 if

(isPartialSpecialization)

8466

isPartialSpecialization))

8471 if

(isPartialSpecialization) {

8489 Diag

(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)

8493

S, TagSpec, TUK, KWLoc, SS,

ClassTemplate

->getIdentifier(),

8497

TemplateParameterLists.data());

8502

= cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);

8505 Context

, Kind, DC, KWLoc, TemplateNameLoc, TemplateParams,

8509 if

(TemplateParameterLists.size() > 1 && SS.

()) {

8511 Context

, TemplateParameterLists.drop_back(1));

8515 ClassTemplate

->AddPartialSpecialization(Partial, InsertPos);

8532 if

(TemplateParameterLists.size() > 0) {

8534

TemplateParameterLists);

8567 Diag

(TemplateNameLoc, diag::err_specialization_after_instantiation)

8571

diag::note_instantiation_required_here)

8609 if

(ModulePrivateLoc.

())

8611

<< (isPartialSpecialization? 1 : 0)

8637

Name, TemplateNameLoc, TemplateArgs, CanonType);

8674

diag::err_concept_decls_may_only_appear_in_global_namespace_scope);

8678 if

(TemplateParameterLists.size() > 1) {

8679 Diag

(NameLoc, diag::err_concept_extra_headers);

8685 if

(Params->

() == 0) {

8686 Diag

(NameLoc, diag::err_concept_no_parameters);

8693

ParamEnd = Params->

();

8694

ParamIt != ParamEnd; ++ParamIt) {

8695 Decl const

*Param = *ParamIt;

8697 if

(++ParamIt == ParamEnd)

8700

diag::err_template_param_pack_must_be_last_template_parameter);

8711 Diag

(NameLoc, diag::err_concept_no_associated_constraints);

8732 bool Found

false

;

8748 Expr

*ConstraintExpr,

8750

assert(!

->hasDefinition() &&

"Concept already defined"

);

8753 C

->setDefinition(ConstraintExpr);

8764 bool

AddToScope =

true

;

8768 if

(!WasAlreadyAdded && AddToScope)

8781 auto

*OldConcept = dyn_cast<ConceptDecl>(

.getRepresentativeDecl()->getUnderlyingDecl());

8783 auto

*Old =

.getRepresentativeDecl();

8784 Diag

(NewDecl->

(), diag::err_redefinition_different_kind)

8787

AddToScope =

false

;

8793 Diag

(NewDecl->

(), diag::err_redefinition_different_concept)

8796

AddToScope =

false

;

8804

AddToScope =

false

;

8807 if

.isSingleResult()) {

8818 if

Concept

->isInvalidDecl() && !

Concept

->hasDefinition()) {

8820 Diag

(

Concept

->getLocation(), diag::note_declared_at);

8829 if

(MinGW || (isa<FunctionDecl>(

) &&

8830

cast<FunctionDecl>(

)->isFunctionTemplateSpecialization()))

8831 D

dropAttrs

<DLLImportAttr, DLLExportAttr>();

8834

FD->setInlineSpecified(

false

);

8845 for

(

*Prev =

; Prev && !PrevDiagLoc.

();

8846

Prev = Prev->getPreviousDecl()) {

8847

PrevDiagLoc = Prev->getLocation();

8849

assert(PrevDiagLoc.

() &&

8850 "Explicit instantiation without point of instantiation?"

);

8860 bool

&HasNoEffect) {

8861

HasNoEffect =

false

;

8868 "previous declaration must be implicit!"

);

8881 if

(PrevPointOfInstantiation.

()) {

8895

PrevPointOfInstantiation.

()) &&

8896 "Explicit instantiation without point of instantiation?"

);

8910 Diag

(NewLoc, diag::err_specialization_after_instantiation)

8912 Diag

(PrevPointOfInstantiation, diag::note_instantiation_required_here)

8917

llvm_unreachable(

"The switch over PrevTSK must be exhaustive."

);

8923

HasNoEffect =

true

;

8938

HasNoEffect =

true

;

8947

diag::err_explicit_instantiation_declaration_after_definition);

8953

diag::note_explicit_instantiation_definition_here);

8954

HasNoEffect =

true

;

8957

llvm_unreachable(

"Unexpected TemplateSpecializationKind!"

);

8973 Diag

(NewLoc, diag::warn_explicit_instantiation_after_specialization)

8976

diag::note_previous_template_specialization);

8977

HasNoEffect =

true

;

8992

HasNoEffect =

true

;

9007

? diag::ext_explicit_instantiation_duplicate

9008

: diag::err_explicit_instantiation_duplicate)

9011

diag::note_previous_explicit_instantiation);

9012

HasNoEffect =

true

;

9017

llvm_unreachable(

"Missing specialization/instantiation case?"

);

9027 enum

DiscardReason { NotAFunctionTemplate, NotAMemberOfEnclosing };

9031 if

(!isa<FunctionTemplateDecl>(

)) {

9033

DiscardedCandidates.push_back(std::make_pair(NotAFunctionTemplate,

));

9040

DiscardedCandidates.push_back(std::make_pair(NotAMemberOfEnclosing,

));

9048 Diag

(FD->

(), diag::err_dependent_function_template_spec_no_match)

9050 for

(

auto

: DiscardedCandidates)

9051 Diag

(

.second->getLocation(),

9052

diag::note_dependent_function_template_spec_discard_reason)

9053

.first << IsFriend;

9058

ExplicitTemplateArgs);

9071

llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>

9072

ConvertedTemplateArgs;

9095 if

(

auto

*NewMD = dyn_cast<CXXMethodDecl>(FD);

9096

().CPlusPlus14 && NewMD && NewMD->isConstexpr() &&

9097

!isa<CXXConstructorDecl, CXXDestructorDecl>(NewMD)) {

9098 auto

*OldMD = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());

9099 if

(OldMD && OldMD->isConst()) {

9109 if

(ExplicitTemplateArgs)

9110

Args = *ExplicitTemplateArgs;

9122

cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),

9123

ExplicitTemplateArgs ? &Args :

nullptr

, FT,

, Info);

9128

I.getPair(), FunTmpl->getTemplatedDecl(),

9144

I.getPair(), FunTmpl->getTemplatedDecl(),

9151 if

(ExplicitTemplateArgs)

9160 if

(QualifiedFriend && Candidates.

()) {

9166 if

(

auto

*OldFD = dyn_cast<FunctionDecl>(OldND->getUnderlyingDecl()))

9177 PDiag

(diag::err_function_template_spec_ambiguous)

9178

<< FD->

getDeclName

() << (ExplicitTemplateArgs !=

nullptr

9179 PDiag

(diag::note_function_template_spec_matched));

9188 const auto

*DSA = PT->getAttr<NoSpecializationsAttr>()) {

9189 auto

Message = DSA->getMessage();

9191

<< PT << !Message.empty() << Message;

9192 Diag

(DSA->getLoc(), diag::note_marked_here) << DSA;

9220 auto

*SpecializationFPT =

9231

assert(SpecInfo &&

"Function template specialization info missing?"

);

9269 bool

HasNoEffect =

false

;

9295 "This must be the only existing declaration of this specialization"

);

9310

FD->setFunctionTemplateSpecialization(

9313

ExplicitTemplateArgs ? &ConvertedTemplateArgs[

] :

nullptr

);

9332

assert(!

->isTemplateDecl() && !

->getDescribedTemplate() &&

9333 "Only for non-template members"

);

9336 NamedDecl

*FoundInstantiation =

nullptr

;

9346 auto

*Method = dyn_cast<CXXMethodDecl>(Candidate->getUnderlyingDecl());

9364

Method->getTrailingRequiresClause() &&

9368

!Satisfaction.IsSatisfied))

9371

Candidates.

addDecl

(Candidate);

9375 if

(Candidates.

())

9384 auto

*Method = cast<CXXMethodDecl>(I->getUnderlyingDecl());

9388

BestMethod = Method;

9392

FoundInstantiation = *Best;

9393

Instantiation = BestMethod;

9398 bool

Ambiguous =

false

;

9401 auto

*Method = cast<CXXMethodDecl>(I->getUnderlyingDecl());

9410 Diag

(

->getLocation(), diag::err_function_member_spec_ambiguous)

9411

<< (InstantiatedFrom ? InstantiatedFrom : Instantiation);

9412 for

(

NamedDecl

*Candidate : Candidates) {

9413

Candidate = Candidate->getUnderlyingDecl();

9414 Diag

(Candidate->getLocation(), diag::note_function_member_spec_matched)

9419

}

else if

(isa<VarDecl>(

)) {

9422

(PrevVar = dyn_cast<VarDecl>(

.getFoundDecl())))

9424

FoundInstantiation =

.getRepresentativeDecl();

9425

Instantiation = PrevVar;

9429

}

else if

(isa<RecordDecl>(

)) {

9432

(PrevRecord = dyn_cast<CXXRecordDecl>(

.getFoundDecl()))) {

9433

FoundInstantiation =

.getRepresentativeDecl();

9434

Instantiation = PrevRecord;

9438

}

else if

(isa<EnumDecl>(

)) {

9441

(PrevEnum = dyn_cast<EnumDecl>(

.getFoundDecl()))) {

9442

FoundInstantiation =

.getRepresentativeDecl();

9443

Instantiation = PrevEnum;

9449 if

(!Instantiation) {

9463 if

(InstantiatedFrom && isa<CXXMethodDecl>(

)) {

9464

cast<CXXMethodDecl>(

)->setInstantiationOfMemberFunction(

9465

cast<CXXMethodDecl>(InstantiatedFrom),

9467

}

else if

(InstantiatedFrom && isa<CXXRecordDecl>(

)) {

9468

cast<CXXRecordDecl>(

)->setInstantiationOfMemberClass(

9469

cast<CXXRecordDecl>(InstantiatedFrom),

9474 Previous

.addDecl(FoundInstantiation);

9479 if

(!InstantiatedFrom) {

9480 Diag

(

->getLocation(), diag::err_spec_member_not_instantiated)

9492

assert(MSInfo &&

"Member specialization info missing?"

);

9494 bool

HasNoEffect =

false

;

9506

Instantiation,

->getLocation(),

9512 if

(

auto

*MemberFunction = dyn_cast<FunctionDecl>(

)) {

9513 FunctionDecl

*InstantiationFunction = cast<FunctionDecl>(Instantiation);

9518 if

(InstantiationFunction->

isDeleted

()) {

9521

InstantiationFunction);

9527

MemberFunction->setInstantiationOfMemberFunction(

9529

}

else if

(

auto

*MemberVar = dyn_cast<VarDecl>(

)) {

9530

MemberVar->setInstantiationOfStaticDataMember(

9532

}

else if

(

auto

*MemberClass = dyn_cast<CXXRecordDecl>(

)) {

9533

MemberClass->setInstantiationOfMemberClass(

9535

}

else if

(

auto

*MemberEnum = dyn_cast<EnumDecl>(

)) {

9536

MemberEnum->setInstantiationOfMemberEnum(

9539

llvm_unreachable(

"unknown member specialization kind"

);

9545 Previous

.addDecl(FoundInstantiation);

9554template

typename

DeclT>

9565

OrigD->setLocation(

);

9570 NamedDecl

*Instantiation = cast<NamedDecl>(

->getCanonicalDecl());

9571 if

(Instantiation ==

)

9574 if

(

auto

Function

= dyn_cast<CXXMethodDecl>(Instantiation))

9576 else if

(

auto

*Var = dyn_cast<VarDecl>(Instantiation))

9578 else if

(

auto

= dyn_cast<CXXRecordDecl>(Instantiation))

9580 else if

(

auto

Enum

= dyn_cast<EnumDecl>(Instantiation))

9583

llvm_unreachable(

"unknown member specialization kind"

);

9591 bool

WasQualifiedName) {

9596

(InstLoc, diag::err_explicit_instantiation_in_class)

9609 if

(WasQualifiedName) {

9610 if

(CurContext->

Encloses

(OrigContext))

9617 if

(

NamespaceDecl

*NS = dyn_cast<NamespaceDecl>(OrigContext)) {

9618 if

(WasQualifiedName)

9621

diag::err_explicit_instantiation_out_of_scope :

9622

diag::warn_explicit_instantiation_out_of_scope_0x)

9627

diag::err_explicit_instantiation_unqualified_wrong_namespace :

9628

diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)

9633

diag::err_explicit_instantiation_must_be_global :

9634

diag::warn_explicit_instantiation_must_be_global_0x)

9643 bool

WasQualifiedName,

9650

(InstLoc, diag::err_explicit_instantiation_internal_linkage) <<

;

9678 if

(isa<TemplateSpecializationType>(

))

9688 auto

*A = cast_or_null<InheritableAttr>(

getDLLAttr

(Def));

9689

assert(A &&

"dllExportImportClassTemplateSpecialization called " 9690 "on Def without dllexport or dllimport"

);

9695 "delayed exports present at explicit instantiation"

);

9699 for

(

auto

&B : Def->

bases

()) {

9700 if

(

auto

*BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(

9701

B.getType()->getAsCXXRecordDecl()))

9721 "Invalid enum tag in class template explicit instantiation!"

);

9727 Diag

(TemplateNameLoc, diag::err_tag_reference_non_tag)

9728

<< TD << NTK << llvm::to_underlying(Kind);

9734

Kind,

false

, KWLoc,

9736 Diag

(KWLoc, diag::err_use_with_wrong_tag)

9741

diag::note_previous_use);

9758 if

(AL.getKind() == ParsedAttr::AT_DLLExport) {

9760

diag::warn_attribute_dllexport_explicit_instantiation_decl);

9761 Diag

(AL.getLoc(), diag::note_attribute);

9766 if

(

auto

*A =

ClassTemplate

->getTemplatedDecl()->getAttr<DLLExportAttr>()) {

9768

diag::warn_attribute_dllexport_explicit_instantiation_decl);

9769 Diag

(A->getLocation(), diag::note_attribute);

9775 bool

DLLImportExplicitInstantiationDef =

false

;

9780 ClassTemplate

->getTemplatedDecl()->getAttr<DLLImportAttr>();

9782 if

(AL.getKind() == ParsedAttr::AT_DLLImport)

9784 if

(AL.getKind() == ParsedAttr::AT_DLLExport) {

9792

DLLImportExplicitInstantiationDef =

true

;

9811 void

*InsertPos =

nullptr

;

9823 if

(AL.getKind() == ParsedAttr::AT_DLLExport) {

9825

diag::warn_attribute_dllexport_explicit_instantiation_def);

9837 bool

HasNoEffect =

false

;

9840

PrevDecl, PrevDecl_TSK,

9857

PrevDecl =

nullptr

;

9861

DLLImportExplicitInstantiationDef) {

9863

HasNoEffect =

false

;

9878 if

(

const auto

*A = PrevDecl->

getAttr

<MSInheritanceAttr>()) {

9880

Clone->setInherited(

true

);

9886 if

(!HasNoEffect && !PrevDecl) {

9899 bool

PreviouslyDLLExported =

->hasAttr<DLLExportAttr>();

9924

= cast_or_null<ClassTemplateSpecializationDecl>(

9936

Def = cast_or_null<ClassTemplateSpecializationDecl>(

9944

DLLImportExplicitInstantiationDef)) {

9953 auto

*A = cast<InheritableAttr>(

9955

A->setInherited(

true

);

9963 bool

NewlyDLLExported =

9964

!PreviouslyDLLExported &&

->hasAttr<DLLExportAttr>();

9980 "Def and Specialization should match for implicit instantiation"

);

9988

PrevDecl->

hasAttr

<DLLExportAttr>()) {

10012 bool

Owned =

false

;

10013 bool

IsDependent =

false

;

10021

assert(!IsDependent &&

"explicit instantiation of dependent name not yet handled"

);

10026 TagDecl

*Tag = cast<TagDecl>(TagD);

10027

assert(!Tag->isEnum() &&

"shouldn't see enumerations here"

);

10029 if

(Tag->isInvalidDecl())

10035 Diag

(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)

10037 Diag

(

->getLocation(), diag::note_nontemplate_decl_here);

10048 Diag

(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)

10063

= cast_or_null<CXXRecordDecl>(

->getPreviousDecl());

10068 bool

HasNoEffect =

false

;

10069

assert(MSInfo &&

"No member specialization information?"

);

10081

= cast_or_null<CXXRecordDecl>(

->getDefinition());

10089 Diag

(TemplateLoc, diag::err_explicit_instantiation_undefined_member)

10090

<< 0 <<

->getDeclName() <<

->getDeclContext();

10100

RecordDef = cast_or_null<CXXRecordDecl>(

->getDefinition());

10129 if

.isInvalidType())

10131

diag::err_explicit_instantiation_requires_name)

10138

S = S->getDeclParent();

10150 Diag

(

.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)

10153

}

else if

(

.getDeclSpec().getStorageClassSpec()

10156 Diag

(

.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)

10159 D

.getMutableDeclSpec().ClearStorageClassSpecs();

10167 if

(

.getDeclSpec().isInlineSpecified())

10168 Diag

(

.getDeclSpec().getInlineSpecLoc(),

10170

diag::err_explicit_instantiation_inline :

10171

diag::warn_explicit_instantiation_inline_0x)

10173 if

(

.getDeclSpec().hasConstexprSpecifier() && R->

isFunctionType

())

10176 Diag

(

.getDeclSpec().getConstexprSpecLoc(),

10177

diag::err_explicit_instantiation_constexpr);

10182 Diag

(

.getDeclSpec().

(), diag::err_deduction_guide_specialized)

10213 if

(!PrevTemplate) {

10216 Diag

(

.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)

10220 Diag

((*P)->getLocation(), diag::note_explicit_instantiation_here);

10226 Diag

(

.getIdentifierLoc(),

10227

diag::err_explicit_instantiation_data_member_not_instantiated)

10229 Diag

(Prev->

(), diag::note_explicit_instantiation_here);

10242 Diag

(

->getTypeLoc().getBeginLoc(),

10243

diag::err_auto_not_allowed_var_inst);

10251 Diag

(

.getIdentifierLoc(),

10252

diag::err_explicit_instantiation_without_template_id)

10254 Diag

(PrevTemplate->getLocation(),

10255

diag::note_explicit_instantiation_here);

10264 D

.getIdentifierLoc(), TemplateArgs);

10272 Diag

(

.getIdentifierLoc(), diag::err_explicit_instantiation_dependent);

10278

Prev = cast<VarDecl>(Res.

());

10292 Diag

(

.getIdentifierLoc(),

10293

diag::ext_explicit_instantiation_without_qualified_id)

10294

<< Prev <<

.getCXXScopeSpec().getRange();

10301 bool

HasNoEffect =

false

;

10303

PrevTSK, POI, HasNoEffect))

10306 if

(!HasNoEffect) {

10309 if

(

auto

*VTSD = dyn_cast<VarTemplatePartialSpecializationDecl>(Prev)) {

10310

VTSD->setExternKeywordLoc(ExternLoc);

10311

VTSD->setTemplateKeywordLoc(TemplateLoc);

10325 Diag

(

->getTypeLoc().getBeginLoc(),

10326

diag::err_invalid_var_template_spec_type)

10327

<< 0 << PrevTemplate << R << Prev->

getType

();

10328 Diag

(PrevTemplate->getLocation(), diag::note_template_declared_here)

10329

<< 2 << PrevTemplate->getDeclName();

10334 return

(

nullptr

;

10339 bool

HasExplicitTemplateArgs =

false

;

10343

HasExplicitTemplateArgs =

true

;

10356 P

!= PEnd; ++

) {

10358 if

(!HasExplicitTemplateArgs) {

10359 if

(

CXXMethodDecl

*Method = dyn_cast<CXXMethodDecl>(Prev)) {

10363 if

(Method->getPrimaryTemplate()) {

10364

TemplateMatches.

addDecl

(Method,

.getAccess());

10367 C

.FoundDecl =

.getPair();

10368 C

.Function = Method;

10371 if

(Method->getTrailingRequiresClause() &&

10375 C

.Viable =

false

;

10390

FunTmpl, (HasExplicitTemplateArgs ? &TemplateArgs :

nullptr

), R,

10421 if

(!NonTemplateMatches.

()) {

10432

Msg = diag::err_explicit_instantiation_ambiguous;

10436

Msg = diag::err_explicit_instantiation_no_candidate;

10452

TemplateMatches.

(), TemplateMatches.

(),

10453

FailedTemplateCandidates,

.getIdentifierLoc(),

10454 PDiag

(diag::err_explicit_instantiation_not_known) << Name,

10455 PDiag

(diag::err_explicit_instantiation_ambiguous) << Name,

10456 PDiag

(diag::note_explicit_instantiation_candidate));

10458 if

(

== TemplateMatches.

())

10472 if

(FPT->hasExceptionSpec()) {

10474

diag::err_mismatched_exception_spec_explicit_instantiation;

10476

DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;

10479 PDiag

(diag::note_explicit_instantiation_here),

10489 Diag

(

.getIdentifierLoc(),

10490

diag::err_explicit_instantiation_member_function_not_instantiated)

10499 if

(!PrevDecl &&

->isThisDeclarationADefinition())

10503 bool

HasNoEffect =

false

;

10514 return

(

nullptr

;

10525 if

(

auto

*RD = dyn_cast<CXXRecordDecl>(

->getDeclContext()))

10526 if

(RD->getIdentifier() && RD->getIdentifier()->isStr(

"valarray"

) &&

10527

RD->isInStdNamespace())

10528 return

(

nullptr

;

10541 Specialization

->setTemplateSpecializationKind(TSK,

.getIdentifierLoc());

10559 D

.getCXXScopeSpec().isSet() &&

10561 Diag

(

.getIdentifierLoc(),

10562

diag::ext_explicit_instantiation_without_qualified_id)

10569 D

.getIdentifierLoc(),

.getCXXScopeSpec().isSet(), TSK);

10572 return

(

nullptr

;

10581

assert(Name &&

"Expected a name in a dependent tag"

);

10590 Diag

(NameLoc, diag::err_dependent_tag_decl)

10617 if

(TypenameLoc.

() && S && !S->getTemplateParamParent())

10620

diag::warn_cxx98_compat_typename_outside_of_template :

10621

diag::ext_typename_outside_of_template)

10631

TypenameLoc, QualifierLoc, II, IdLoc, &TSI,

10645 if

(TypenameLoc.

() && S && !S->getTemplateParamParent())

10648

diag::warn_cxx98_compat_typename_outside_of_template :

10649

diag::ext_typename_outside_of_template)

10654 if

(TypenameLoc.

()) {

10657 if

(LookupRD && LookupRD->getIdentifier() == TemplateII) {

10658 Diag

(TemplateIILoc,

10659

diag::ext_out_of_line_qualified_id_type_names_constructor)

10661

<< (TemplateKWLoc.

() ? 1 : 0

);

10672

assert(DTN &&

"dependent template has non-dependent name?"

);

10673

assert(DTN->getQualifier() == SS.

());

10675 if

(!DTN->isIdentifier()) {

10676 Diag

(TemplateIILoc, diag::err_template_id_not_a_type) << Template;

10683

DTN->getIdentifier(), TemplateArgs.

arguments

());

10695 for

(

unsigned

I = 0, N = TemplateArgs.

(); I != N; ++I)

10712 for

(

unsigned

I = 0, N = TemplateArgs.

(); I != N; ++I)

10730 if

(!II.

isStr

(

"type"

))

10739 if

(!EnableIfTSTLoc || EnableIfTSTLoc.

() == 0)

10752 if

(!EnableIfII || !EnableIfII->

isStr

(

"enable_if"

))

10780 bool

DeducedTSTContext) {

10782

DeducedTSTContext);

10787 if

(isa<DependentNameType>(

)) {

10811

SS.

(QualifierLoc);

10814 if

(QualifierLoc) {

10841 unsigned

DiagID = 0;

10842 Decl

*Referenced =

nullptr

;

10843 switch

(

.getResultKind()) {

10848 Expr

*Cond =

nullptr

;

10849 if

(Ctx &&

isEnableIf

(QualifierLoc, II, CondRange, Cond)) {

10854

std::string FailedDescription;

10855

std::tie(FailedCond, FailedDescription) =

10859

diag::err_typename_nested_not_found_requirement)

10860

<< FailedDescription

10866

diag::err_typename_nested_not_found_enable_if)

10867

<< Ctx << CondRange;

10871

DiagID = Ctx ? diag::err_typename_nested_not_found

10872

: diag::err_unknown_typename;

10881 Diag

(IILoc, diag::err_typename_refers_to_using_value_decl)

10882

<< Name << Ctx << FullRange;

10884

= dyn_cast<UnresolvedUsingValueDecl>(

.getRepresentativeDecl())){

10886 Diag

(

, diag::note_using_value_decl_missing_typename)

10916 auto

*LookupRD = dyn_cast_or_null<CXXRecordDecl>(Ctx);

10917 auto

*FoundRD = dyn_cast<CXXRecordDecl>(

Type

);

10919

FoundRD->isInjectedClassName() &&

10921 Diag

(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)

10938 if

(!DeducedTSTContext) {

10943 Diag

(IILoc, diag::err_dependent_deduced_tst)

10946 Diag

(IILoc, diag::err_deduced_tst)

10958

DiagID = Ctx ? diag::err_typename_nested_not_type

10959

: diag::err_typename_not_type;

10960

Referenced =

.getFoundDecl();

10964

DiagID = Ctx ? diag::err_typename_nested_not_type

10965

: diag::err_typename_not_type;

10966

Referenced = *

.begin();

10978 Diag

(IILoc, DiagID) << FullRange << Name << Ctx;

10980 Diag

(IILoc, DiagID) << FullRange << Name;

10983

Ctx ? diag::note_typename_member_refers_here

10984

: diag::note_typename_refers_here)

10991 class

CurrentInstantiationRebuilder

10999

CurrentInstantiationRebuilder(

&SemaRef,

11003 Loc

(

), Entity(Entity) { }

11010 bool

AlreadyTransformed(

QualType T

) {

11025

this->Entity = Entity;

11041

CurrentInstantiationRebuilder Rebuilder(*

this

, Name);

11042 return

Rebuilder.TransformType(

);

11046

CurrentInstantiationRebuilder Rebuilder(*

this

(),

11048 return

Rebuilder.TransformExpr(

);

11056

CurrentInstantiationRebuilder Rebuilder(*

this

, SS.

getRange

().

(),

11059

= Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);

11063

SS.

(Rebuilt);

11069 for

(

unsigned

I = 0, N = Params->

(); I != N; ++I) {

11073 if

(isa<TemplateTypeParmDecl>(Param))

11078

= dyn_cast<TemplateTemplateParmDecl>(Param)) {

11080

TTP->getTemplateParameters()))

11122 unsigned

NumArgs) {

11124

llvm::raw_svector_ostream Out(Str);

11126 if

(!Params || Params->

() == 0 || NumArgs == 0)

11127 return

std::string();

11129 for

(

unsigned

I = 0, N = Params->

(); I != N; ++I) {

11139

Out <<

->getName();

11151 return

std::string(Out.str());

11159 auto

LPT = std::make_unique<LateParsedTemplate>();

11162

LPT->Toks.swap(Toks);

11209class

ExplicitSpecializationVisibilityChecker {

11221 if

(

auto

*FD = dyn_cast<FunctionDecl>(ND))

11222 return

checkImpl(FD);

11223 if

(

auto

*RD = dyn_cast<CXXRecordDecl>(ND))

11224 return

checkImpl(RD);

11225 if

(

auto

*VD = dyn_cast<VarDecl>(ND))

11226 return

checkImpl(VD);

11227 if

(

auto

*ED = dyn_cast<EnumDecl>(ND))

11228 return

checkImpl(ED);

11232 void

diagnose(

NamedDecl

bool

IsPartialSpec) {

11233 auto Kind

= IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization

11234

: Sema::MissingImportKind::ExplicitSpecialization;

11235 const bool

Recover =

true

;

11240 if

(Modules.empty())

11246 bool

CheckMemberSpecialization(

const NamedDecl

) {

11247 return Kind

== Sema::AcceptableKind::Visible

11252 bool

CheckExplicitSpecialization(

const NamedDecl

) {

11253 return Kind

== Sema::AcceptableKind::Visible

11258 bool

CheckDeclaration(

const NamedDecl

) {

11275 template

typename

SpecDecl>

11276 void

checkImpl(SpecDecl *Spec) {

11277 bool

IsHiddenExplicitSpecialization =

false

;

11279

IsHiddenExplicitSpecialization = Spec->getMemberSpecializationInfo()

11280

? !CheckMemberSpecialization(Spec)

11281

: !CheckExplicitSpecialization(Spec);

11283

checkInstantiated(Spec);

11286 if

(IsHiddenExplicitSpecialization)

11287

diagnose(Spec->getMostRecentDecl(),

false

);

11296 auto

*SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);

11300 auto

From = SD->getSpecializedTemplateOrPartial();

11303 else if

(

auto

*TD =

11305 if

(!CheckDeclaration(TD))

11306

diagnose(TD,

true

);

11311 void

checkInstantiated(

VarDecl

*RD) {

11312 auto

*SD = dyn_cast<VarTemplateSpecializationDecl>(RD);

11316 auto

From = SD->getSpecializedTemplateOrPartial();

11319 else if

(

auto

*TD =

11321 if

(!CheckDeclaration(TD))

11322

diagnose(TD,

true

);

11327 void

checkInstantiated(

EnumDecl

*FD) {}

11329 template

typename

TemplDecl>

11330 void

checkTemplate(TemplDecl *TD) {

11331 if

(TD->isMemberSpecialization()) {

11332 if

(!CheckMemberSpecialization(TD))

11333

diagnose(TD->getMostRecentDecl(),

false

);

11343

ExplicitSpecializationVisibilityChecker(*

this

11353

ExplicitSpecializationVisibilityChecker(*

this