RetroSearch Browse

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

311class

InitListChecker {

313 bool

hadError =

false

;

315 bool

TreatUnavailableAsInvalid;

316 bool

InOverloadResolution;

321 unsigned

CurEmbedIndex = 0;

332 unsigned

&StructuredIndex);

336 bool

TopLevelObject =

false

);

339 bool

SubobjectIsDesignatorContext,

342 unsigned

&StructuredIndex,

343 bool

TopLevelObject =

false

);

348 unsigned

&StructuredIndex,

349 bool

DirectlyDesignated =

false

);

354 unsigned

&StructuredIndex);

359 unsigned

&StructuredIndex);

364 unsigned

&StructuredIndex);

368 unsigned

&StructuredIndex);

373 bool

SubobjectIsDesignatorContext,

unsigned

&Index,

375 unsigned

&StructuredIndex,

376 bool

TopLevelObject =

false

);

379

llvm::APSInt elementIndex,

380 bool

SubobjectIsDesignatorContext,

unsigned

&Index,

382 unsigned

&StructuredIndex);

388

llvm::APSInt *NextElementIndex,

391 unsigned

&StructuredIndex,

392 bool

FinishSubobjectInit,

393 bool

TopLevelObject);

397 unsigned

StructuredIndex,

399 bool

IsFullyOverwritten =

false

);

400 void

UpdateStructuredListElement(

*StructuredList,

401 unsigned

&StructuredIndex,

405 unsigned

ExpectedNumInits);

406 int

numArrayElements(

DeclType);

407 int

numStructUnionElements(

DeclType);

415 bool

UnionOverride =

false

416 bool

FullyOverwritten =

true

) {

421

? (UnionOverride ? diag::ext_initializer_union_overrides

422

: diag::ext_initializer_overrides)

423

: diag::warn_initializer_overrides;

425 if

(InOverloadResolution && SemaRef.

().CPlusPlus) {

446

DiagID = diag::err_initializer_overrides_destructed;

466

<< NewInitRange << FullyOverwritten << OldInit->

();

467

SemaRef.

(OldInit->

(), diag::note_previous_initializer)

495 bool

FillWithNoInit);

496 void

FillInEmptyInitForField(

unsigned Init

FieldDecl

*Field,

499 bool

FillWithNoInit =

false

);

503 bool

FillWithNoInit =

false

);

506 bool

TopLevelObject);

511 Expr

*Result =

nullptr

;

523

assert(AType &&

"expected array type when initializing array"

);

525 if

(

const auto

*CAType = dyn_cast<ConstantArrayType>(AType))

526

ElsCount = std::min(CAType->getSize().getZExtValue(),

527

ElsCount - CurEmbedIndex);

535

Result =

new

(SemaRef.

)

537

CurEmbedIndex, ElsCount);

538

CurEmbedIndex += ElsCount;

549 bool

VerifyOnly,

bool

TreatUnavailableAsInvalid,

550 bool

InOverloadResolution =

false

555

: InitListChecker(S, Entity, IL,

true

558

&AggrDeductionCandidateParamTypes) {}

560 bool

HadError() {

return

hadError; }

564 InitListExpr

*getFullyStructuredList()

const

{

return

FullyStructuredList; }

581 bool

EmptyInitList = SemaRef.

().CPlusPlus11 &&

594

InitExpr = VerifyOnly ? &DummyInitList

611 if

(!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==

615

InitSeq.getFailedCandidateSet()

616

.BestViableFunction(SemaRef,

Kind

.getLocation(), Best);

618

assert(O ==

OR_Success

"Inconsistent overload resolution"

);

625 bool

IsInStd =

false

;

627

ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {

632 if

(IsInStd && llvm::StringSwitch<bool>(R->

getName

())

633

.Cases(

"basic_string"

"deque"

"forward_list"

true

)

634

.Cases(

"list"

"map"

"multimap"

"multiset"

true

)

635

.Cases(

"priority_queue"

"queue"

"set"

"stack"

true

)

636

.Cases(

"unordered_map"

"unordered_set"

"vector"

true

)

638

InitSeq.InitializeFrom(

642

TreatUnavailableAsInvalid);

647

diag::warn_invalid_initializer_from_system_header);

650

diag::note_used_in_initialization_here);

652

SemaRef.

(

, diag::note_used_in_initialization_here);

659

InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);

662

diag::note_in_omitted_aggregate_initializer)

665 bool

IsTrailingArrayNewMember =

668

SemaRef.

(

, diag::note_in_omitted_aggregate_initializer)

669

<< (IsTrailingArrayNewMember ? 2 :

678

: InitSeq.Perform(SemaRef, Entity,

Kind

, SubInit);

686 if

(FullyStructuredList)

688

PerformEmptyInit(

, Entity);

691void

InitListChecker::FillInEmptyInitForBase(

694 bool

&RequiresSecondPass,

bool

FillWithNoInit) {

696

SemaRef.

, &

false

, &ParentEntity);

701

: PerformEmptyInit(ILE->

(), BaseEntity);

708

assert(Init < ILE->getNumInits() &&

"should have been expanded"

);

713

FillInEmptyInitializations(BaseEntity, InnerILE, RequiresSecondPass,

714

ILE,

, FillWithNoInit);

716

dyn_cast<DesignatedInitUpdateExpr>(ILE->

(

))) {

717

FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),

718

RequiresSecondPass, ILE,

723void

InitListChecker::FillInEmptyInitForField(

unsigned Init

FieldDecl

*Field,

726 bool

&RequiresSecondPass,

727 bool

FillWithNoInit) {

735 if

(!RType->getDecl()->isUnion())

736

assert((

< NumInits || VerifyOnly) &&

737 "This ILE should have been expanded"

);

739 if

(FillWithNoInit) {

740

assert(!VerifyOnly &&

"should not fill with no-init in verify-only mode"

);

742 if

(

< NumInits)

749 if

(!VerifyOnly &&

->hasAttr<ExplicitInitAttr>()) {

750

SemaRef.

(ILE->

(), diag::warn_field_requires_explicit_init)

752

SemaRef.

(

->getLocation(), diag::note_entity_declared_at)

760 if

(

->hasInClassInitializer()) {

786 if

(

< NumInits)

790

RequiresSecondPass =

true

;

795 if

(

->getType()->isReferenceType()) {

801

SemaRef.

(

, diag::err_init_reference_member_uninitialized)

805

SemaRef.

(

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

811 ExprResult

MemberInit = PerformEmptyInit(

, MemberEntity);

817 if

(hadError || VerifyOnly) {

819

}

else if

(

< NumInits) {

821

}

else if

(!isa<ImplicitValueInitExpr>(MemberInit.

())) {

827

RequiresSecondPass =

true

;

830

= dyn_cast<InitListExpr>(ILE->

(

))) {

831

FillInEmptyInitializations(MemberEntity, InnerILE,

832

RequiresSecondPass, ILE,

, FillWithNoInit);

834

dyn_cast<DesignatedInitUpdateExpr>(ILE->

(

))) {

835

FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),

836

RequiresSecondPass, ILE,

847 bool

&RequiresSecondPass,

850 bool

FillWithNoInit) {

852 "Should not have void type"

);

856 if

(FillWithNoInit && VerifyOnly)

866 struct

UpdateOuterILEWithUpdatedInit {

869

~UpdateOuterILEWithUpdatedInit() {

873

} UpdateOuterRAII = {OuterILE, OuterIndex};

884

RequiresSecondPass, FillWithNoInit);

886

assert((!RDecl->

() || !isa<CXXRecordDecl>(RDecl) ||

887

!cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) &&

888 "We should have computed initialized fields already"

);

892 unsigned

NumElems = numStructUnionElements(ILE->

());

895 if

(!VerifyOnly && ILE->

() < NumElems)

900 if

(

auto

*CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {

901 for

(

auto

: CXXRD->bases()) {

905

FillInEmptyInitForBase(

, Entity, ILE, RequiresSecondPass,

911 for

(

auto

*Field : RDecl->

()) {

912 if

(

->isUnnamedBitField())

918

FillInEmptyInitForField(

, Field, Entity, ILE, RequiresSecondPass,

940

ElementType = AType->getElementType();

941 if

(

const auto

*CAType = dyn_cast<ConstantArrayType>(AType))

942

NumElements = CAType->getZExtSize();

950

ElementType = VType->getElementType();

951

NumElements = VType->getNumElements();

955

ElementType = ILE->

();

957 bool

SkipEmptyInitChecks =

false

;

958 for

(uint64_t

= 0;

!= NumElements; ++

) {

970 if

(!InitExpr && Init < NumInits && ILE->hasArrayFiller())

975 if

(SkipEmptyInitChecks)

978 Expr

*Filler =

nullptr

;

984

PerformEmptyInit(ILE->

(), ElementEntity);

995

}

else if

(VerifyOnly) {

996

SkipEmptyInitChecks =

true

;

997

}

else if

(

< NumInits) {

1012 if

(!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {

1018

RequiresSecondPass =

true

;

1022

= dyn_cast_or_null<InitListExpr>(InitExpr)) {

1023

FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,

1024

ILE,

, FillWithNoInit);

1026

dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr)) {

1027

FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),

1028

RequiresSecondPass, ILE,

1036 if

(isa_and_nonnull<DesignatedInitExpr>(

))

1041

InitListChecker::InitListChecker(

1043 bool

VerifyOnly,

bool

TreatUnavailableAsInvalid,

bool

InOverloadResolution,

1045

: SemaRef(S), VerifyOnly(VerifyOnly),

1046

TreatUnavailableAsInvalid(TreatUnavailableAsInvalid),

1047

InOverloadResolution(InOverloadResolution),

1048

AggrDeductionCandidateParamTypes(AggrDeductionCandidateParamTypes) {

1050

FullyStructuredList =

1059

CheckExplicitInitList(Entity, IL,

, FullyStructuredList,

1062 if

(!hadError && !AggrDeductionCandidateParamTypes && FullyStructuredList) {

1063 bool

RequiresSecondPass =

false

;

1064

FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass,

1066 if

(RequiresSecondPass && !hadError)

1067

FillInEmptyInitializations(Entity, FullyStructuredList,

1068

RequiresSecondPass,

nullptr

, 0);

1070 if

(hadError && FullyStructuredList)

1074int

InitListChecker::numArrayElements(

DeclType) {

1076 int

maxElements = 0x7FFFFFFF;

1079

maxElements =

static_cast<int>

(CAT->getZExtSize());

1084int

InitListChecker::numStructUnionElements(

DeclType) {

1086 int

InitializableMembers = 0;

1087 if

(

auto

*CXXRD = dyn_cast<CXXRecordDecl>(structDecl))

1088

InitializableMembers += CXXRD->getNumBases();

1089 for

(

const auto

*Field : structDecl->

())

1090 if

->isUnnamedBitField())

1091

++InitializableMembers;

1094 return

std::min(InitializableMembers, 1);

1100 return

RT->getDecl();

1102 return

Inject->getDecl();

1132 if

(

CXXRecordDecl

*CXXRD = dyn_cast<CXXRecordDecl>(ParentRD)) {

1133 if

(CXXRD->getNumBases()) {

1137 auto

FieldIt = ParentRD->field_begin();

1138

assert(FieldIt != ParentRD->field_end() &&

1139 "no fields but have initializer for member?"

);

1140 return

++FieldIt == ParentRD->field_end();

1156 unsigned

&StructuredIndex) {

1157 int

maxElements = 0;

1160

maxElements = numArrayElements(

);

1162

maxElements = numStructUnionElements(

);

1166

llvm_unreachable(

"CheckImplicitInitList(): Illegal type"

);

1168 if

(maxElements == 0) {

1171

diag::err_implicit_empty_initializer);

1178 InitListExpr

*StructuredSubobjectInitList = getStructuredSubobjectInit(

1179

ParentIList, Index,

, StructuredList, StructuredIndex,

1182 unsigned

StructuredSubobjectInitIndex = 0;

1185 unsigned

StartIndex = Index;

1186

CheckListElementTypes(Entity, ParentIList,

1188

StructuredSubobjectInitList,

1189

StructuredSubobjectInitIndex);

1191 if

(StructuredSubobjectInitList) {

1192

StructuredSubobjectInitList->

setType

(

);

1194 unsigned

EndIndex = (Index == StartIndex? StartIndex : Index - 1);

1197 if

(EndIndex < ParentIList->getNumInits() &&

1198

ParentIList->

(EndIndex)) {

1209

diag::warn_missing_braces)

1212

StructuredSubobjectInitList->

(),

"{"

)

1215

StructuredSubobjectInitList->

()),

1221 if

(!VerifyOnly && CXXRD && CXXRD->hasUserDeclaredConstructor()) {

1223

diag::warn_cxx20_compat_aggregate_init_with_ctors)

1239 unsigned

DiagID = 0;

1251

DiagID = diag::warn_braces_around_init;

1258

DiagID = diag::warn_braces_around_init;

1284

llvm_unreachable(

"unexpected braced scalar init"

);

1303 bool

TopLevelObject) {

1304 unsigned

Index = 0, StructuredIndex = 0;

1305

CheckListElementTypes(Entity, IList,

true

1306

Index, StructuredList, StructuredIndex, TopLevelObject);

1307 if

(StructuredList) {

1313

StructuredList->

setType

(ExprTy);

1321 bool

ExtraInitsIsError = SemaRef.

().CPlusPlus ||

1323

hadError = ExtraInitsIsError;

1326

}

else if

(StructuredIndex == 1 &&

1331

? diag::err_excess_initializers_in_char_array_initializer

1332

: diag::ext_excess_initializers_in_char_array_initializer;

1336 unsigned

DK = ExtraInitsIsError

1337

? diag::err_excess_initializers_for_sizeless_type

1338

: diag::ext_excess_initializers_for_sizeless_type;

1348 unsigned

DK = ExtraInitsIsError ? diag::err_excess_initializers

1349

: diag::ext_excess_initializers;

1357

!isa<InitListExpr>(IList->

(0)))

1363 if

(CXXRD && CXXRD->hasUserDeclaredConstructor()) {

1366 bool

HasEquivCtor =

false

;

1369

HasEquivCtor = CD && !CD->

isDeleted

();

1372 if

(!HasEquivCtor) {

1374

diag::warn_cxx20_compat_aggregate_init_with_ctors)

1384 bool

SubobjectIsDesignatorContext,

1387 unsigned

&StructuredIndex,

1388 bool

TopLevelObject) {

1392

CheckComplexType(Entity, IList, DeclType, Index,

1393

StructuredList, StructuredIndex);

1395

CheckScalarType(Entity, IList, DeclType, Index,

1396

StructuredList, StructuredIndex);

1398

CheckVectorType(Entity, IList, DeclType, Index,

1399

StructuredList, StructuredIndex);

1400

}

else if

(

const RecordDecl

*RD = getRecordDecl(DeclType)) {

1406 "non-aggregate records should be handed in CheckSubElementType"

);

1407 if

(

auto

*CXXRD = dyn_cast<CXXRecordDecl>(RD))

1408

Bases = CXXRD->bases();

1410

Bases = cast<CXXRecordDecl>(RD)->bases();

1412

CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(),

1413

SubobjectIsDesignatorContext, Index, StructuredList,

1414

StructuredIndex, TopLevelObject);

1419

CheckArrayType(Entity, IList, DeclType, Zero,

1420

SubobjectIsDesignatorContext, Index,

1421

StructuredList, StructuredIndex);

1426

SemaRef.

(IList->

(), diag::err_illegal_initializer_type)

1430

CheckReferenceType(Entity, IList, DeclType, Index,

1431

StructuredList, StructuredIndex);

1434

SemaRef.

(IList->

(), diag::err_init_objc_class) << DeclType;

1439

CheckScalarType(Entity, IList, DeclType, Index, StructuredList,

1446

assert(AggrDeductionCandidateParamTypes);

1447

AggrDeductionCandidateParamTypes->push_back(DeclType);

1450

SemaRef.

(IList->

(), diag::err_illegal_initializer_type)

1461 unsigned

&StructuredIndex,

1462 bool

DirectlyDesignated) {

1466 return

CheckReferenceType(Entity, IList, ElemType, Index,

1467

StructuredList, StructuredIndex);

1470 if

(SubInitList->getNumInits() == 1 &&

1475 expr

= SubInitList->getInit(0);

1478

}

else if

(isa<ImplicitValueInitExpr>(

)) {

1482 "found implicit initialization for the wrong type"

);

1483

UpdateStructuredListElement(StructuredList, StructuredIndex,

);

1505 if

(TmpEntity.getType()->isDependentType()) {

1510

assert(AggrDeductionCandidateParamTypes);

1524 if

(isa<InitListExpr, DesignatedInitExpr>(

) ||

1525

!isa_and_present<ConstantArrayType>(

1528

AggrDeductionCandidateParamTypes->push_back(ElemType);

1540 if

(

|| isa<InitListExpr>(

)) {

1541 if

(

auto

*Embed = dyn_cast<EmbedExpr>(

)) {

1542 expr

= HandleEmbed(Embed, Entity);

1546 if

(Result.isInvalid())

1549

UpdateStructuredListElement(StructuredList, StructuredIndex,

1550

Result.getAs<

>());

1551

}

else if

) {

1553

}

else if

(StructuredList) {

1554

UpdateStructuredListElement(StructuredList, StructuredIndex,

1559 if

(AggrDeductionCandidateParamTypes)

1560

AggrDeductionCandidateParamTypes->push_back(ElemType);

1568 return

CheckScalarType(Entity, IList, ElemType, Index,

1569

StructuredList, StructuredIndex);

1583

UpdateStructuredListElement(StructuredList, StructuredIndex,

);

1612

UpdateStructuredListElement(StructuredList, StructuredIndex,

1630

CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,

1635 if

(DirectlyDesignated && SemaRef.

().CPlusPlus && !hadError) {

1636 if

(InOverloadResolution)

1639

SemaRef.

(

->getBeginLoc(),

1640

diag::ext_designated_init_brace_elision)

1641

->getSourceRange()

1656

assert(

Copy

.isInvalid() &&

1657 "expected non-aggregate initialization to fail"

);

1669 unsigned

&StructuredIndex) {

1670

assert(Index == 0 &&

"Index in explicit init list must be zero"

);

1680 return

CheckScalarType(Entity, IList, DeclType, Index, StructuredList,

1685 if

(!SemaRef.

().CPlusPlus && !VerifyOnly)

1686

SemaRef.

(IList->

(), diag::ext_complex_component_init)

1694 for

(

unsigned

i = 0; i < 2; ++i) {

1696

CheckSubElementType(ElementEntity, IList, elementType, Index,

1697

StructuredList, StructuredIndex);

1705 unsigned

&StructuredIndex) {

1712

? diag::warn_cxx98_compat_empty_sizeless_initializer

1713

: diag::err_empty_sizeless_initializer)

1718

? diag::warn_cxx98_compat_empty_scalar_initializer

1719

: diag::err_empty_scalar_initializer)

1735

SemaRef.

(SubIList->getBeginLoc(), diag::ext_many_braces_around_init)

1738

CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,

1741

}

else if

(isa<DesignatedInitExpr>(

)) {

1743

SemaRef.

(

->getBeginLoc(),

1744

diag::err_designator_for_scalar_or_sizeless_init)

1746

->getSourceRange();

1751

}

else if

(

auto

*Embed = dyn_cast<EmbedExpr>(

)) {

1752 expr

= HandleEmbed(Embed, Entity);

1758

Result = getDummyInit();

1767 Expr

*ResultExpr =

nullptr

;

1769 if

(Result.isInvalid())

1772

ResultExpr = Result.getAs<

>();

1774 if

(ResultExpr !=

&& !VerifyOnly && !CurEmbed) {

1777

IList->

(Index, ResultExpr);

1781

UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);

1784 if

(AggrDeductionCandidateParamTypes)

1785

AggrDeductionCandidateParamTypes->push_back(DeclType);

1792 unsigned

&StructuredIndex) {

1800

diag::err_init_reference_member_uninitialized)

1809 if

(isa<InitListExpr>(

) && !SemaRef.

().CPlusPlus11) {

1811

SemaRef.

(IList->

(), diag::err_init_non_aggr_init_list)

1822

Result = getDummyInit();

1831 if

(Result.isInvalid())

1836 if

(!VerifyOnly &&

)

1839

UpdateStructuredListElement(StructuredList, StructuredIndex,

);

1841 if

(AggrDeductionCandidateParamTypes)

1842

AggrDeductionCandidateParamTypes->push_back(DeclType);

1849 unsigned

&StructuredIndex) {

1852 unsigned

numEltsInit = 0;

1857

CheckEmptyInitializable(

1867 if

(!isa<InitListExpr>(

) &&

->getType()->isVectorType()) {

1871

Result = getDummyInit();

1880 Expr

*ResultExpr =

nullptr

;

1881 if

(Result.isInvalid())

1884

ResultExpr = Result.getAs<

>();

1886 if

(ResultExpr !=

&& !VerifyOnly) {

1889

IList->

(Index, ResultExpr);

1892

UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);

1894 if

(AggrDeductionCandidateParamTypes)

1895

AggrDeductionCandidateParamTypes->push_back(elementType);

1902 for

(

unsigned

i = 0; i < maxElements; ++i, ++numEltsInit) {

1905

CheckEmptyInitializable(ElementEntity, IList->

());

1910

CheckSubElementType(ElementEntity, IList, elementType, Index,

1911

StructuredList, StructuredIndex);

1919 if

(isBigEndian && (

->getVectorKind() == VectorKind::Neon ||

1920 T

->getVectorKind() == VectorKind::NeonPoly)) {

1932

diag::warn_neon_vector_initializer_non_portable);

1934 const char

*typeCode;

1944

llvm_unreachable(

"Invalid element type!"

);

1948

? diag::note_neon_vector_initializer_non_portable_q

1949

: diag::note_neon_vector_initializer_non_portable)

1950

<< typeCode << typeSize;

1960 for

(

unsigned

i = 0; i < maxElements; ++i) {

1969

CheckSubElementType(ElementEntity, IList, elementType, Index,

1970

StructuredList, StructuredIndex);

1982

CheckSubElementType(ElementEntity, IList, VecType, Index,

1983

StructuredList, StructuredIndex);

1984

numEltsInit += numIElts;

1989 if

(numEltsInit != maxElements) {

1992

diag::err_vector_incorrect_num_elements)

1993

<< (numEltsInit < maxElements) << maxElements << numEltsInit

2020

SemaRef.

(diag::err_access_dtor_temp)

2034

InitType =

Parent

->getType();

2040

ExprList.size() == 1

2041

? dyn_cast_if_present<EmbedExpr>(ExprList[0]->IgnoreParens())

2056

llvm::APSInt elementIndex,

2057 bool

SubobjectIsDesignatorContext,

2060 unsigned

&StructuredIndex) {

2078 if

(Index < IList->getNumInits()) {

2091 if

(StructuredList) {

2092

UpdateStructuredListElement(StructuredList, StructuredIndex,

2097 if

(AggrDeductionCandidateParamTypes)

2098

AggrDeductionCandidateParamTypes->push_back(DeclType);

2119

SemaRef.

(VAT->getSizeExpr()->getBeginLoc(),

2120

diag::err_variable_object_no_init)

2121

<< VAT->getSizeExpr()->getSourceRange();

2130

llvm::APSInt maxElements(elementIndex.getBitWidth(),

2131

elementIndex.isUnsigned());

2132 bool

maxElementsKnown =

false

;

2134

maxElements = CAT->getSize();

2135

elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());

2136

elementIndex.setIsUnsigned(maxElements.isUnsigned());

2137

maxElementsKnown =

true

;

2141 while

(Index < IList->getNumInits()) {

2147 if

(!SubobjectIsDesignatorContext)

2152 if

(CheckDesignatedInitializer(Entity, IList, DIE, 0,

2153

DeclType,

nullptr

, &elementIndex, Index,

2154

StructuredList, StructuredIndex,

true

2160 if

(elementIndex.getBitWidth() > maxElements.getBitWidth())

2161

maxElements = maxElements.extend(elementIndex.getBitWidth());

2162 else if

(elementIndex.getBitWidth() < maxElements.getBitWidth())

2163

elementIndex = elementIndex.extend(maxElements.getBitWidth());

2164

elementIndex.setIsUnsigned(maxElements.isUnsigned());

2168 if

(!maxElementsKnown && elementIndex > maxElements)

2169

maxElements = elementIndex;

2176 if

(maxElementsKnown && elementIndex == maxElements)

2180

SemaRef.

, StructuredIndex, Entity);

2182 unsigned

EmbedElementIndexBeforeInit = CurEmbedIndex;

2184

CheckSubElementType(ElementEntity, IList, elementType, Index,

2185

StructuredList, StructuredIndex);

2187 if

((CurEmbed || isa<EmbedExpr>(

)) && elementType->

isScalarType

()) {

2190

elementIndex + CurEmbedIndex - EmbedElementIndexBeforeInit - 1;

2192 auto

Embed = cast<EmbedExpr>(

);

2194

EmbedElementIndexBeforeInit - 1;

2200 if

(!maxElementsKnown && elementIndex > maxElements)

2201

maxElements = elementIndex;

2206

llvm::APSInt

Zero

(maxElements.getBitWidth(), maxElements.isUnsigned());

2210

SemaRef.

(IList->

(), diag::ext_typecheck_zero_array_size);

2214

elementType, maxElements,

nullptr

, ArraySizeModifier::Normal, 0);

2221 if

((maxElementsKnown && elementIndex < maxElements) ||

2223

CheckEmptyInitializable(

2232 bool

TopLevelObject) {

2234 unsigned

FlexArrayDiag;

2235 if

(isa<InitListExpr>(InitExpr) &&

2236

cast<InitListExpr>(InitExpr)->getNumInits() == 0) {

2238

FlexArrayDiag = diag::ext_flexible_array_init;

2239

}

else if

(!TopLevelObject) {

2241

FlexArrayDiag = diag::err_flexible_array_init;

2244

FlexArrayDiag = diag::err_flexible_array_init;

2245

}

else if

(cast<VarDecl>(Entity.

())->hasLocalStorage()) {

2247

FlexArrayDiag = diag::err_flexible_array_init;

2250

FlexArrayDiag = diag::ext_flexible_array_init;

2256

SemaRef.

(

->getLocation(), diag::note_flexible_array_member)

2260 return

FlexArrayDiag != diag::ext_flexible_array_init;

2264 return

StructuredList && StructuredList->

() == 1U;

2267void

InitListChecker::CheckStructUnionTypes(

2270 bool

SubobjectIsDesignatorContext,

unsigned

&Index,

2271 InitListExpr

*StructuredList,

unsigned

&StructuredIndex,

2272 bool

TopLevelObject) {

2273 const RecordDecl

*RD = getRecordDecl(DeclType);

2295 if

(isa<CXXRecordDecl>(RD) &&

2296

cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {

2297 if

(!StructuredList)

2300

Field != FieldEnd; ++Field) {

2301 if

(

->hasInClassInitializer() ||

2302

(

->isAnonymousStructOrUnion() &&

2303 Field

->getType()->getAsCXXRecordDecl()->hasInClassInitializer())) {

2309

llvm_unreachable(

"Couldn't find in-class initializer"

);

2315

Field != FieldEnd; ++Field) {

2316 if

->isUnnamedBitField()) {

2317

CheckEmptyInitializable(

2328 bool

InitializedSomething =

false

;

2331 for

(

auto

I = Bases.begin(),

= Bases.end(); I !=

; ++I) {

2337 if

(isa_and_nonnull<DesignatedInitExpr>(

))

2354 if

(AggrDeductionCandidateParamTypes &&

.isPackExpansion()) {

2355

AggrDeductionCandidateParamTypes->push_back(

2360 if

(Index < IList->getNumInits())

2372

CheckSubElementType(BaseEntity, IList,

.getType(), Index,

2373

StructuredList, StructuredIndex);

2374

InitializedSomething =

true

;

2376

CheckEmptyInitializable(BaseEntity, InitLoc);

2391 size_t

NumRecordDecls = llvm::count_if(RD->

decls

(), [&](

const Decl

) {

2392

return isa<FieldDecl>(D) || isa<RecordDecl>(D);

2394 bool

HasDesignatedInit =

false

;

2398 while

(Index < IList->getNumInits()) {

2406 if

(!SubobjectIsDesignatorContext)

2409

HasDesignatedInit =

true

;

2413 bool

DesignatedInitFailed = CheckDesignatedInitializer(

2414

Entity, IList, DIE, 0, DeclType, &Field,

nullptr

, Index,

2415

StructuredList, StructuredIndex,

true

, TopLevelObject);

2416 if

(DesignatedInitFailed)

2421 if

(!VerifyOnly &&

->isFieldDesignator()) {

2423

InitializedFields.insert(F);

2424 if

(!DesignatedInitFailed) {

2433

InitializedSomething =

true

;

2450 if

(NumRecordDecls == 1)

2452 if

(

const auto

*IL = dyn_cast<IntegerLiteral>(I))

2453 return

IL->getValue().isZero();

2461

SemaRef.

(InitLoc, diag::err_non_designated_init_used);

2466 if

(Field == FieldEnd) {

2472 if

(InitializedSomething && RD->

())

2476 if

(

->getType()->isIncompleteArrayType())

2479 if

(

->isUnnamedBitField()) {

2488

InvalidUse = !SemaRef.

CanUseDecl

(*Field, TreatUnavailableAsInvalid);

2509

CheckSubElementType(MemberEntity, IList,

->getType(), Index,

2510

StructuredList, StructuredIndex);

2511

InitializedSomething =

true

;

2512

InitializedFields.insert(*Field);

2524 bool

IsCDesignatedInitializer =

2525

HasDesignatedInit && !SemaRef.

().CPlusPlus;

2526 if

(!VerifyOnly && InitializedSomething && !RD->

() &&

2528

!IsCDesignatedInitializer) {

2535 if

(HasDesignatedInit && InitializedFields.count(*it))

2538 if

(!it->isUnnamedBitField() && !it->hasInClassInitializer() &&

2539

!it->getType()->isIncompleteArrayType()) {

2540 auto Diag

= HasDesignatedInit

2541

? diag::warn_missing_designated_field_initializers

2542

: diag::warn_missing_field_initializers;

2551 if

(!StructuredList && Field != FieldEnd && !RD->

() &&

2552

->getType()->isIncompleteArrayType()) {

2553 for

(;

!= FieldEnd && !hadError; ++

) {

2554 if

->isUnnamedBitField() && !

->hasInClassInitializer())

2555

CheckEmptyInitializable(

2576 if

(Field == FieldEnd || !

->getType()->isIncompleteArrayType() ||

2580 if

(CheckFlexibleArrayInit(Entity, IList->

(Index), *Field,

2590 if

(isa<InitListExpr>(IList->

(Index)) ||

2591

AggrDeductionCandidateParamTypes)

2592

CheckSubElementType(MemberEntity, IList,

->getType(), Index,

2593

StructuredList, StructuredIndex);

2595

CheckImplicitInitList(MemberEntity, IList,

->getType(), Index,

2596

StructuredList, StructuredIndex);

2617

PE = IndirectField->

chain_end

(); PI != PE; ++PI) {

2625

assert(isa<FieldDecl>(*PI));

2626

Replacements.back().setFieldDecl(cast<FieldDecl>(*PI));

2633

&Replacements[0] + Replacements.size());

2640 for

(

unsigned

I = 0; I < NumIndexExprs; ++I)

2654 explicit

FieldInitializerValidatorCCC(

const RecordDecl

*RD)

2662

std::unique_ptr<CorrectionCandidateCallback>

clone

()

override

{

2663 return

std::make_unique<FieldInitializerValidatorCCC>(*

this

);

2716

llvm::APSInt *NextElementIndex,

2719 unsigned

&StructuredIndex,

2720 bool

FinishSubobjectInit,

2721 bool

TopLevelObject) {

2722 if

(DesigIdx == DIE->

()) {

2729

assert(isa<InitListExpr>(

) &&

2730 "designator result in direct non-list initialization?"

);

2735 if

(StructuredList) {

2739

UpdateStructuredListElement(StructuredList, StructuredIndex,

2743 if

(AggrDeductionCandidateParamTypes)

2744

AggrDeductionCandidateParamTypes->push_back(CurrentObjectType);

2749 bool

prevHadError = hadError;

2754 unsigned

OldIndex = Index;

2757

CheckSubElementType(Entity, IList, CurrentObjectType, Index, StructuredList,

2758

StructuredIndex,

true

);

2764

IList->

(OldIndex, DIE);

2766 return

hadError && !prevHadError;

2770 bool

IsFirstDesignator = (DesigIdx == 0);

2771 if

(IsFirstDesignator ? FullyStructuredList : StructuredList) {

2774 if

(IsFirstDesignator)

2775

StructuredList = FullyStructuredList;

2777 Expr

*ExistingInit = StructuredIndex < StructuredList->getNumInits() ?

2778

StructuredList->getInit(StructuredIndex) :

nullptr

;

2779 if

(!ExistingInit && StructuredList->hasArrayFiller())

2780

ExistingInit = StructuredList->getArrayFiller();

2783

StructuredList = getStructuredSubobjectInit(

2784

IList, Index, CurrentObjectType, StructuredList, StructuredIndex,

2786 else if

(

*Result = dyn_cast<InitListExpr>(ExistingInit))

2787

StructuredList = Result;

2800

diagnoseInitOverride(ExistingInit,

2807

dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))

2808

StructuredList =

->getUpdater();

2813

StructuredList->updateInit(SemaRef.

, StructuredIndex, DIUE);

2822

StructuredList =

nullptr

;

2828 if

(

->isFieldDesignator()) {

2838 RecordDecl

*RD = getRecordDecl(CurrentObjectType);

2842 Loc

->getFieldLoc();

2844

SemaRef.

(

, diag::err_field_designator_non_aggr)

2845

<< SemaRef.

().CPlusPlus << CurrentObjectType;

2854 if

(

auto

*FD = dyn_cast_if_present<FieldDecl>(VD)) {

2856

}

else if

(

auto

*IFD = dyn_cast_if_present<IndirectFieldDecl>(VD)) {

2862

KnownField = cast<FieldDecl>(*IFD->chain_begin());

2878

!Lookup.

empty

()) {

2879

SemaRef.

(

->getFieldLoc(), diag::err_field_designator_nonfield)

2881

SemaRef.

(Lookup.front()->getLocation(),

2882

diag::note_field_designator_found);

2889

FieldInitializerValidatorCCC CCC(RD);

2896

SemaRef.

(diag::err_field_designator_unknown_suggest)

2897

<< FieldName << CurrentObjectType);

2898

KnownField = Corrected.getCorrectionDeclAs<

FieldDecl

>();

2909

SemaRef.

(

, diag::err_field_designator_unknown)

2917 unsigned

NumBases = 0;

2918 if

(

auto

*CXXRD = dyn_cast<CXXRecordDecl>(RD))

2919

NumBases = CXXRD->getNumBases();

2921 unsigned

FieldIndex = NumBases;

2923 for

(

auto

*FI : RD->

()) {

2924 if

(FI->isUnnamedBitField())

2940 if

(StructuredList) {

2941 FieldDecl

*CurrentField = StructuredList->getInitializedFieldInUnion();

2943

assert(StructuredList->getNumInits() == 1

2944

"A union should never have more than one initializer!"

);

2946 Expr

*ExistingInit = StructuredList->getInit(0);

2949

diagnoseInitOverride(

2957

StructuredList->resizeInits(SemaRef.

, 0);

2958

StructuredList->setInitializedFieldInUnion(

nullptr

);

2961

StructuredList->setInitializedFieldInUnion(*Field);

2968

InvalidUse = !SemaRef.

CanUseDecl

(*Field, TreatUnavailableAsInvalid);

2991 if

(IsFirstDesignator && !VerifyOnly && SemaRef.

().CPlusPlus &&

2994

(*NextField)->getFieldIndex() >

->getFieldIndex() + 1)) {

2998 if

(FI->isUnnamedBitField())

3009

diag::ext_designated_init_reordered)

3012 unsigned

OldIndex = StructuredIndex - 1;

3013 if

(StructuredList && OldIndex <= StructuredList->getNumInits()) {

3014 if

(

*PrevInit = StructuredList->getInit(OldIndex)) {

3015

SemaRef.

(PrevInit->getBeginLoc(),

3016

diag::note_previous_field_init)

3026 D

->setFieldDecl(*Field);

3030 if

(StructuredList && FieldIndex >= StructuredList->getNumInits())

3031

StructuredList->resizeInits(SemaRef.

, FieldIndex + 1);

3034 if

(

->getType()->isIncompleteArrayType()) {

3036 if

((DesigIdx + 1) != DIE->

()) {

3043

diag::err_designator_into_flexible_array_member)

3045

SemaRef.

(

->getLocation(), diag::note_flexible_array_member)

3051 if

(!hadError && !isa<InitListExpr>(DIE->

()) &&

3052

!isa<StringLiteral>(DIE->

())) {

3056

diag::err_flexible_array_init_needs_braces)

3058

SemaRef.

(

->getLocation(), diag::note_flexible_array_member)

3065 if

Invalid

&& CheckFlexibleArrayInit(Entity, DIE->

(), *Field,

3075 bool

prevHadError = hadError;

3076 unsigned

newStructuredIndex = FieldIndex;

3077 unsigned

OldIndex = Index;

3082

CheckSubElementType(MemberEntity, IList,

->getType(), Index,

3083

StructuredList, newStructuredIndex);

3085

IList->

(OldIndex, DIE);

3086 if

(hadError && !prevHadError) {

3090

*NextField =

;

3091

StructuredIndex = FieldIndex;

3097 unsigned

newStructuredIndex = FieldIndex;

3101 if

(CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,

3102

FieldType,

nullptr

, Index,

3103

StructuredList, newStructuredIndex,

3104

FinishSubobjectInit,

false

))

3115 if

(IsFirstDesignator) {

3120

*NextField =

;

3122

StructuredIndex = FieldIndex;

3126 if

(!FinishSubobjectInit)

3134 bool

prevHadError = hadError;

3139

CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,

3140 false

, Index, StructuredList, FieldIndex);

3141 return

hadError && !prevHadError;

3162

SemaRef.

(

->getLBracketLoc(), diag::err_array_designator_non_array)

3163

<< CurrentObjectType;

3168 Expr

*IndexExpr =

nullptr

;

3169

llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;

3170 if

(

->isArrayDesignator()) {

3173

DesignatedEndIndex = DesignatedStartIndex;

3175

assert(

->isArrayRangeDesignator() &&

"Need array-range designator"

);

3177

DesignatedStartIndex =

3179

DesignatedEndIndex =

3188 if

(DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&

3193 if

(isa<ConstantArrayType>(AT)) {

3194

llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(),

false

);

3195

DesignatedStartIndex

3196

= DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());

3197

DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());

3199

= DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());

3200

DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());

3201 if

(DesignatedEndIndex >= MaxElements) {

3204

diag::err_array_designator_too_large)

3211 unsigned

DesignatedIndexBitWidth =

3213

DesignatedStartIndex =

3214

DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);

3215

DesignatedEndIndex =

3216

DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);

3217

DesignatedStartIndex.setIsUnsigned(

true

);

3218

DesignatedEndIndex.setIsUnsigned(

true

);

3221 bool

IsStringLiteralInitUpdate =

3222

StructuredList && StructuredList->isStringLiteralInit();

3223 if

(IsStringLiteralInitUpdate && VerifyOnly) {

3226

StructuredList =

nullptr

;

3227

}

else if

(IsStringLiteralInitUpdate) {

3240 unsigned

PromotedCharTyWidth = Context.

getTypeSize

(PromotedCharTy);

3242 if

(

StringLiteral

*SL = dyn_cast<StringLiteral>(SubExpr)) {

3245 if

(cast<ConstantArrayType>(AT)->getSize().ult(StrLen))

3246

StrLen = cast<ConstantArrayType>(AT)->getZExtSize();

3247

StructuredList->resizeInits(Context, StrLen);

3251 for

(

unsigned

i = 0, e = StrLen; i != e; ++i) {

3252

llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));

3254

Context, CodeUnit, PromotedCharTy, SubExpr->

());

3255 if

(CharTy != PromotedCharTy)

3259

StructuredList->updateInit(Context, i,

);

3268 if

(cast<ConstantArrayType>(AT)->getSize().ult(StrLen))

3269

StrLen = cast<ConstantArrayType>(AT)->getZExtSize();

3270

StructuredList->resizeInits(Context, StrLen);

3274 for

(

unsigned

i = 0, e = StrLen; i != e; ++i) {

3275

llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);

3277

Context, CodeUnit, PromotedCharTy, SubExpr->

());

3278 if

(CharTy != PromotedCharTy)

3282

StructuredList->updateInit(Context, i,

);

3289 if

(StructuredList &&

3290

DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())

3291

StructuredList->resizeInits(SemaRef.

3292

DesignatedEndIndex.getZExtValue() + 1);

3298 unsigned

ElementIndex = DesignatedStartIndex.getZExtValue();

3299 unsigned

OldIndex = Index;

3304 while

(DesignatedStartIndex <= DesignatedEndIndex) {

3310 if

(CheckDesignatedInitializer(

3311

ElementEntity, IList, DIE, DesigIdx + 1, ElementType,

nullptr

3312 nullptr

, Index, StructuredList, ElementIndex,

3313

FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),

3318

++DesignatedStartIndex;

3319

ElementIndex = DesignatedStartIndex.getZExtValue();

3324 if

(IsFirstDesignator) {

3325 if

(NextElementIndex)

3326

*NextElementIndex = DesignatedStartIndex;

3327

StructuredIndex = ElementIndex;

3331 if

(!FinishSubobjectInit)

3335 bool

prevHadError = hadError;

3336

CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,

3338

StructuredList, ElementIndex);

3339 return

hadError && !prevHadError;

3345

InitListChecker::getStructuredSubobjectInit(

*IList,

unsigned

Index,

3348 unsigned

StructuredIndex,

3350 bool

IsFullyOverwritten) {

3351 if

(!StructuredList)

3354 Expr

*ExistingInit =

nullptr

;

3355 if

(StructuredIndex < StructuredList->getNumInits())

3356

ExistingInit = StructuredList->

(StructuredIndex);

3358 if

(

*Result = dyn_cast_or_null<InitListExpr>(ExistingInit))

3367 if

(!IsFullyOverwritten)

3390

diagnoseInitOverride(ExistingInit, InitRange);

3393 unsigned

ExpectedNumInits = 0;

3394 if

(Index < IList->getNumInits()) {

3395 if

(

auto

= dyn_cast_or_null<InitListExpr>(IList->

(Index)))

3396

ExpectedNumInits =

->getNumInits();

3398

ExpectedNumInits = IList->

() - Index;

3402

createInitListExpr(CurrentObjectType, InitRange, ExpectedNumInits);

3411

InitListChecker::createInitListExpr(

CurrentObjectType,

3413 unsigned

ExpectedNumInits) {

3417 QualType

ResultType = CurrentObjectType;

3420

Result->setType(ResultType);

3423 unsigned

NumElements = 0;

3428

NumElements = CAType->getZExtSize();

3431 if

(NumElements > ExpectedNumInits)

3435

NumElements = VType->getNumElements();

3437

NumElements = numStructUnionElements(CurrentObjectType);

3442

Result->reserveInits(SemaRef.

, NumElements);

3449void

InitListChecker::UpdateStructuredListElement(

*StructuredList,

3450 unsigned

&StructuredIndex,

3453 if

(!StructuredList)

3457

StructuredIndex,

)) {

3463

diagnoseInitOverride(PrevInit,

->getSourceRange());

3472

InitListChecker Check(*

this

, Entity, From,

true

3475 return

!Check.HadError();

3492 if

(

.isInvalid())

3495 if

(

Value

.isSigned() &&

Value

.isNegative())

3496 return

(

, diag::err_array_designator_negative)

3499 Value

.setIsUnsigned(

true

);

3517 if

(

.isFieldDesignator()) {

3518

Designators.push_back(ASTDesignator::CreateFieldDesignator(

3519 D

.getFieldDecl(),

.getDotLoc(),

.getFieldLoc()));

3520

}

else if

(

.isArrayDesignator()) {

3521 Expr

*Index =

static_cast<Expr

>

(

.getArrayIndex());

3522

llvm::APSInt IndexValue;

3523 if

(!Index->isTypeDependent() && !Index->isValueDependent())

3528

Designators.push_back(ASTDesignator::CreateArrayDesignator(

3529

InitExpressions.size(),

.getLBracketLoc(),

.getRBracketLoc()));

3530

InitExpressions.push_back(Index);

3532

}

else if

(

.isArrayRangeDesignator()) {

3533 Expr

*StartIndex =

static_cast<Expr

>

(

.getArrayRangeStart());

3534 Expr

*EndIndex =

static_cast<Expr

>

(

.getArrayRangeEnd());

3535

llvm::APSInt StartValue;

3536

llvm::APSInt EndValue;

3541 if

(!StartDependent)

3547 if

(!StartIndex || !EndIndex)

3551 if

(StartDependent || EndDependent) {

3553

}

else if

(StartValue.getBitWidth() > EndValue.getBitWidth())

3554

EndValue = EndValue.extend(StartValue.getBitWidth());

3555 else if

(StartValue.getBitWidth() < EndValue.getBitWidth())

3556

StartValue = StartValue.extend(EndValue.getBitWidth());

3558 if

(!StartDependent && !EndDependent && EndValue < StartValue) {

3559 Diag

(

.getEllipsisLoc(), diag::err_array_designator_empty_range)

3564

Designators.push_back(ASTDesignator::CreateArrayRangeDesignator(

3565

InitExpressions.size(),

.getLBracketLoc(),

.getEllipsisLoc(),

3566 D

.getRBracketLoc()));

3567

InitExpressions.push_back(StartIndex);

3568

InitExpressions.push_back(EndIndex);

3578

EqualOrColonLoc, GNUSyntax,

3586

InitializedEntity::InitializedEntity(

ASTContext

&Context,

unsigned

Index,

3591

Kind = EK_ArrayElement;

3594

Kind = EK_VectorElement;

3598

assert(CT &&

"Unexpected type"

);

3599 Kind

= EK_ComplexElement;

3607 bool

IsInheritedVirtualBase,

3612 Result

.Base = {

, IsInheritedVirtualBase};

3630 return Variable

.VariableOrMember->getDeclName();

3652

llvm_unreachable(

"Invalid EntityKind!"

);

3686

llvm_unreachable(

"Invalid EntityKind!"

);

3721unsigned

InitializedEntity::dumpImpl(raw_ostream &OS)

const

{

3724 for

(

unsigned

I = 0; I != Depth; ++I)

3733 case EK_Result

: OS <<

"Result"

;

break

;

3741 case EK_New

: OS <<

"New"

;

break

;

3745 case EK_Base

: OS <<

"Base"

;

break

;

3752

OS <<

"Block (lambda)"

;

3755

OS <<

"LambdaCapture "

;

3762 D

->printQualifiedName(OS);

3765

OS <<

" '"

() <<

"'\n"

;

3771

dumpImpl(llvm::errs());

3826 for

(

const Step

&S : llvm::reverse(Steps)) {

3886

llvm_unreachable(

"Invalid EntityKind!"

);

3894

InitializationSequence

3897 bool

HadMultipleCandidates) {

3901

S.Function.HadMultipleCandidates = HadMultipleCandidates;

3903

S.Function.FoundDecl =

Found

;

3922 bool

BindingTemporary) {

3947 bool

HadMultipleCandidates) {

3951

S.Function.HadMultipleCandidates = HadMultipleCandidates;

3953

S.Function.FoundDecl = FoundDecl;

3992 bool

TopLevelOfInitList) {

4010 bool

HadMultipleCandidates,

bool

FromInitList,

bool

AsInitList) {

4016

S.Function.HadMultipleCandidates = HadMultipleCandidates;

4017

S.Function.Function = Constructor;

4018

S.Function.FoundDecl = FoundDecl;

4061

Steps.insert(Steps.begin(), S);

4081

Steps.push_back(

);

4122 "Can only unwrap trivial init lists."

);

4126

Steps.insert(Steps.begin(), S);

4132 "Can only rewrap trivial init lists."

);

4136

Steps.insert(Steps.begin(), S);

4140

S.WrappingSyntacticList = Syntactic;

4147

this->Failure = Failure;

4148

this->FailedOverloadResult =

;

4169 if

.empty()) {

4189 "consuming an object of unretainable type?"

);

4209 bool

TreatUnavailableAsInvalid) {

4224 Expr

*OVEAsExpr = &OVE;

4227

TreatUnavailableAsInvalid);

4237 bool

TreatUnavailableAsInvalid);

4248 bool

TreatUnavailableAsInvalid) {

4262

List->getNumInits()),

4267

List->getExprLoc(), List->getBeginLoc(), List->getEndLoc());

4269

TreatUnavailableAsInvalid);

4296 bool

CopyInitializing,

bool

AllowExplicit,

bool

OnlyListConstructors,

4297 bool

IsListInit,

bool

RequireActualConstructor,

4298 bool

SecondStepOfCopyInit =

false

) {

4304 if

(!Info.Constructor || Info.Constructor->isInvalidDecl())

4321 bool

SuppressUserConversions =

4322

SecondStepOfCopyInit ||

4323

(IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&

4326 if

(Info.ConstructorTmpl)

4328

Info.ConstructorTmpl, Info.FoundDecl,

4329 nullptr

, Args, CandidateSet, SuppressUserConversions,

4330 false

, AllowExplicit);

4339 bool

AllowExplicitConv = AllowExplicit && !CopyInitializing &&

4343

CandidateSet, SuppressUserConversions,

4344 false

, AllowExplicit,

4360 if

(S.

().CPlusPlus17 && Args.size() == 1 &&

4361

!RequireActualConstructor && !SecondStepOfCopyInit) {

4363 auto

*SourceRD =

->getType()->getAsCXXRecordDecl();

4365 const auto

&Conversions = SourceRD->getVisibleConversionFunctions();

4366 for

(

auto

I = Conversions.begin(),

= Conversions.end(); I !=

; ++I) {

4369 D

->getUnderlyingDecl();

4376

Conv = cast<CXXConversionDecl>(

);

4380

ConvTemplate, I.getPair(), ActingDC,

, DestType,

4381

CandidateSet, AllowExplicit, AllowExplicit,

4385

DestType, CandidateSet, AllowExplicit,

4412 bool

IsListInit =

false

4413 bool

IsInitListCopy =

false

) {

4414

assert(((!IsListInit && !IsInitListCopy) ||

4415

(Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&

4416 "IsListInit/IsInitListCopy must come with a single initializer list " 4419

(IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) :

nullptr

;

4429 bool

RequireActualConstructor =

4435 bool

CopyElisionPossible =

false

;

4436 auto

ElideConstructor = [&] {

4452 if

(S.

().CPlusPlus17 && !RequireActualConstructor &&

4453

UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isPRValue() &&

4475

assert(!IsInitListCopy &&

4476 "IsInitListCopy only possible with aggregate types"

);

4477

CopyElisionPossible =

true

;

4485

assert(DestRecordType &&

"Constructor initialization requires record type"

);

4487

= cast<CXXRecordDecl>(DestRecordType->

());

4495 bool

AllowExplicit = Kind.AllowExplicit() || IsListInit;

4505 bool

AsInitializerList =

false

;

4517

AsInitializerList =

true

;

4523

S, Kind.getLocation(), Args, CandidateSet, DestType, Ctors, Best,

4524

CopyInitialization, AllowExplicit,

4525 true

, IsListInit, RequireActualConstructor);

4540

AsInitializerList =

false

;

4542

S, Kind.getLocation(), UnwrappedArgs, CandidateSet, DestType, Ctors,

4543

Best, CopyInitialization, AllowExplicit,

4544 false

, IsListInit, RequireActualConstructor);

4556 bool

HadMultipleCandidates = (CandidateSet.

() > 1);

4560 if

(

auto

*CD = dyn_cast<CXXConversionDecl>(Best->Function)) {

4562 QualType

ConvType = CD->getConversionType();

4564 "should not have selected this conversion function"

);

4566

HadMultipleCandidates);

4579

DestRecordDecl !=

nullptr

&& DestRecordDecl->

isAggregate

() &&

4581

(Kind.getLocation(), diag::warn_field_requires_explicit_init)

4582

1 << DestRecordDecl;

4607 if

(IsListInit && !Kind.AllowExplicit() && CtorDecl->

isExplicit

()) {

4627

Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,

4628

IsListInit | IsInitListCopy, AsInitializerList);

4641 bool

HadMultipleCandidates =

false

;

4644

UnqualifiedTargetType,

4646

&HadMultipleCandidates)) {

4648

HadMultipleCandidates);

4649

SourceType = Fn->getType();

4668 bool

TopLevelOfInitList);

4682 bool

TreatUnavailableAsInvalid) {

4722

T1Quals, cv2T2, T2, T2Quals, Sequence,

4753

TreatUnavailableAsInvalid);

4785 bool

TreatUnavailableAsInvalid) {

4797

TreatUnavailableAsInvalid);

4835

!IsDesignatedInit) {

4840 Expr

*InitListAsExpr = InitList;

4859 if

(isa<ConstantArrayType>(DestAT) &&

4861

isa<DecompositionDecl>(Entity.

())) {

4864 "Deduced to other type?"

);

4868

Entity, SubInit[0], DestType, Sequence,

4869

TreatUnavailableAsInvalid);

4875 if

(!isa<VariableArrayType>(DestAT) &&

4885

TreatUnavailableAsInvalid);

4918

TreatUnavailableAsInvalid))

4922 Expr

*InitListAsExpr = InitList;

4924

DestType, Sequence,

true

);

4942

ET && ET->getDecl()->isFixed() &&

4991 if

(

->getType()->isRecordType() ||

5002

TreatUnavailableAsInvalid);

5009

InitListChecker CheckInitList(S, Entity, InitList,

5010

DestType,

true

, TreatUnavailableAsInvalid);

5011 if

(CheckInitList.HadError()) {

5033 "Must have incompatible references when binding via conversion"

);

5044 bool

AllowExplicitCtors =

false

;

5045 bool

AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();

5056 if

(!Info.Constructor)

5059 if

(!Info.Constructor->isInvalidDecl() &&

5060

Info.Constructor->isConvertingConstructor(

true

)) {

5061 if

(Info.ConstructorTmpl)

5063

Info.ConstructorTmpl, Info.FoundDecl,

5066 false

, AllowExplicitCtors);

5069

Info.Constructor, Info.FoundDecl,

, CandidateSet,

5071 false

, AllowExplicitCtors);

5086 for

(

auto

I = Conversions.begin(),

= Conversions.end(); I !=

; ++I) {

5089 if

(isa<UsingShadowDecl>(

))

5090 D

= cast<UsingShadowDecl>(

)->getTargetDecl();

5097

Conv = cast<CXXConversionDecl>(

);

5105 if

((AllowRValues ||

5109

ConvTemplate, I.getPair(), ActingDC,

, DestType,

5111 false

, AllowExplicitConvs);

5114

Conv, I.getPair(), ActingDC,

, DestType, CandidateSet,

5115 false

, AllowExplicitConvs);

5137 if

(isa<CXXConversionDecl>(

))

5138

cv3T3 =

->getReturnType();

5150 bool

HadMultipleCandidates = (CandidateSet.

() > 1);

5152

HadMultipleCandidates);

5162

assert(!isa<CXXConstructorDecl>(

) &&

5163 "should not have conversion after constructor"

);

5167

ICS.

Standard

= Best->FinalConversion;

5188 if

(RefConv & Sema::ReferenceConversions::DerivedToBase)

5190 else if

(RefConv & Sema::ReferenceConversions::ObjC)

5192 else if

(RefConv & Sema::ReferenceConversions::Function)

5194 else if

(RefConv & Sema::ReferenceConversions::Qualification) {

5211 bool

TopLevelOfInitList) {

5229

T1Quals, cv2T2, T2, T2Quals, Sequence,

5230

TopLevelOfInitList);

5254 bool

TopLevelOfInitList) {

5278 if

(isLValueRef || T1Function) {

5281

(Kind.isCStyleOrFunctionalCast() &&

5285 if

(RefConv & (Sema::ReferenceConversions::DerivedToBase |

5286

Sema::ReferenceConversions::ObjC)) {

5289 if

(RefConv & (Sema::ReferenceConversions::Qualification))

5293 if

(RefConv & Sema::ReferenceConversions::DerivedToBase)

5297

}

else if

(RefConv & Sema::ReferenceConversions::Qualification) {

5301

}

else if

(RefConv & Sema::ReferenceConversions::Function) {

5321

(isLValueRef || InitCategory.

isRValue

())) {

5326

isLValueRef, Sequence);

5353 else if

(!InitCategory.

isLValue

())

5361 switch

(RefRelationship) {

5373

llvm_unreachable(

"unexpected kind of compatible initializer"

);

5397

(Kind.isCStyleOrFunctionalCast() &&

5426 auto

T1QualsIgnoreAS = T1Quals;

5427 auto

T2QualsIgnoreAS = T2Quals;

5430

T2QualsIgnoreAS.removeAddressSpace();

5433 if

(T1QualsIgnoreAS != T2QualsIgnoreAS)

5443

cv1T4 = cv1T4WithAS;

5448 if

(RefConv & Sema::ReferenceConversions::DerivedToBase)

5450 else if

(RefConv & Sema::ReferenceConversions::ObjC)

5452 else if

(RefConv & Sema::ReferenceConversions::Qualification) {

5469

isLValueRef, Sequence);

5509

Sema::AllowedExplicit::None,

5511

Kind.isCStyleOrFunctionalCast(),

5514 if

(ICS.

isBad

()) {

5530

TopLevelOfInitList);

5539

((T1CVRQuals | T2CVRQuals) != T1CVRQuals ||

5584

assert((!InitList || InitList->

() == 0) &&

5585 "Shouldn't use value-init for non-empty init lists"

);

5591

assert(!

isVoidType

() &&

"Cannot value-init void"

);

5597 if

(

CXXRecordDecl

*ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {

5598 bool

NeedZeroInitialization =

true

;

5613

NeedZeroInitialization =

false

;

5621 if

(NeedZeroInitialization)

5635

ClassDecl->hasUninitializedReferenceMember()) {

5643 Expr

*InitListAsExpr = InitList;

5645 bool

InitListSyntax = InitList;

5650

S, Entity, Kind, Args,

, Entity.

(), Sequence, InitListSyntax);

5674

Entity.

(), Sequence);

5700 unsigned

EntityIndexToProcess = 0;

5703 Expr

*ArrayFiller =

nullptr

;

5704 FieldDecl

*InitializedFieldInUnion =

nullptr

;

5708 Expr

*Arg,

**InitExpr =

nullptr

) {

5710

S, SubEntity, SubKind,

5715

IS.

Diagnose

(S, SubEntity, SubKind,

5726

ER = IS.

Perform

(S, SubEntity, SubKind,

5733

*InitExpr = ER.

();

5735

InitExprs.push_back(ER.

());

5743

uint64_t ArrayLength;

5751

ArrayLength = CAT->getZExtSize();

5752

ResultType = Entity.

();

5759 const Expr

*SE = VAT->getSizeExpr();

5765

ArrayLength = Args.size();

5767

EntityIndexToProcess = ArrayLength;

5771 for

(

: Args) {

5776 if

(!HandleInitializedEntity(SubEntity, SubKind,

))

5784

Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),

true

);

5785 if

(!HandleInitializedEntity(SubEntity, SubKind,

nullptr

, &ArrayFiller))

5789 if

(ResultType.

isNull

()) {

5796 const CXXRecordDecl

*RD = cast<CXXRecordDecl>(RT->getDecl());

5810 if

(EntityIndexToProcess < Args.size()) {

5816 Expr

= Args[EntityIndexToProcess];

5819 if

(!HandleInitializedEntity(SubEntity, SubKind,

))

5827

Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),

5829 if

(!HandleInitializedEntity(SubEntity, SubKind,

nullptr

))

5832

EntityIndexToProcess++;

5845 if

(EntityIndexToProcess < Args.size()) {

5847 Expr

= Args[EntityIndexToProcess];

5856

(FD->

getLocation

(), diag::note_flexible_array_member) << FD;

5865 if

(!HandleInitializedEntity(SubEntity, SubKind,

))

5873

InitializedFieldInUnion = FD;

5874

EntityIndexToProcess = 1;

5880 if

(!VerifyOnly && FD->

hasAttr

<ExplicitInitAttr>()) {

5881

(Kind.getLocation(), diag::warn_field_requires_explicit_init)

5892

Kind.getParenOrBraceRange().getEnd(), FD);

5896

InitExprs.push_back(DIE.

());

5906

(SR.

getEnd

(), diag::err_init_reference_member_uninitialized)

5913

Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),

true

);

5914 if

(!HandleInitializedEntity(SubEntity, SubKind,

nullptr

))

5918

EntityIndexToProcess++;

5920

ResultType = Entity.

();

5925 if

(EntityIndexToProcess < Args.size()) {

5930 SourceRange

ExcessInitSR(Args[EntityIndexToProcess]->getBeginLoc(),

5931

Args.back()->getEndLoc());

5932

(Kind.getLocation(), diag::err_excess_initializers)

5933

<< InitKind << ExcessInitSR;

5947

CPLIE->setArrayFiller(ArrayFiller);

5948 if

(InitializedFieldInUnion)

5949

CPLIE->setInitializedFieldInUnion(InitializedFieldInUnion);

5951

(Kind.getLocation(),

5952

diag::warn_cxx17_compat_aggregate_init_paren_list)

5953

<< Kind.getLocation() << SR << ResultType;

5965 bool

TopLevelOfInitList) {

5966

assert(!DestType->

isReferenceType

() &&

"References are handled elsewhere"

);

5969 "Must have a class type to perform a user-defined conversion"

);

5979 bool

AllowExplicit = Kind.AllowExplicit();

5985

= cast<CXXRecordDecl>(DestRecordType->getDecl());

5991 if

(!Info.Constructor)

5994 if

(!Info.Constructor->isInvalidDecl() &&

5995

Info.Constructor->isConvertingConstructor(

true

)) {

5996 if

(Info.ConstructorTmpl)

5998

Info.ConstructorTmpl, Info.FoundDecl,

6001 false

, AllowExplicit);

6006 false

, AllowExplicit);

6022

= cast<CXXRecordDecl>(SourceRecordType->getDecl());

6024 const auto

&Conversions =

6026 for

(

auto

I = Conversions.begin(),

= Conversions.end(); I !=

; ++I) {

6029 if

(isa<UsingShadowDecl>(

))

6030 D

= cast<UsingShadowDecl>(

)->getTargetDecl();

6037

Conv = cast<CXXConversionDecl>(

);

6041

ConvTemplate, I.getPair(), ActingDC,

, DestType,

6042

CandidateSet, AllowExplicit, AllowExplicit);

6045

DestType, CandidateSet, AllowExplicit,

6071 bool

HadMultipleCandidates = (CandidateSet.

() > 1);

6073 if

(isa<CXXConstructorDecl>(

)) {

6079

HadMultipleCandidates);

6108

HadMultipleCandidates);

6121 Function

->getReturnType()->isReferenceType() ||

6131 if

(Best->FinalConversion.First || Best->FinalConversion.Second ||

6132

Best->FinalConversion.Third) {

6135

ICS.

Standard

= Best->FinalConversion;

6153

isa<CXXBoolLiteralExpr>(

) &&

6154

!cast<CXXBoolLiteralExpr>(

)->getValue() &&

6163 bool

isAddressOf,

bool

&isWeakAccess) {

6169 if

(op->getOpcode() == UO_AddrOf)

6174

}

else if

(

CastExpr

*ce = dyn_cast<CastExpr>(e)) {

6175 switch

(ce->getCastKind()) {

6178 case

CK_LValueBitCast:

6182 case

CK_ArrayToPointerDecay:

6185 case

CK_NullToPointer:

6193

}

else if

(isa<DeclRefExpr>(e)) {

6197

isWeakAccess =

true

;

6201 VarDecl

*var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());

6215

}

else if

(isa<ArraySubscriptExpr>(e)) {

6231 bool

isWeakAccess =

false

;

6235 if

(S.

().ObjCAutoRefCount && isWeakAccess)

6267 bool

ArrayDecay =

false

;

6272

ArgPointee = ArgArrayType->getElementType();

6284 bool

ShouldCopy =

true

;

6355 "cl_intel_device_side_avc_motion_estimation"

, S.

()) &&

6357 if

(DestType->isOCLIntelSubgroupAVCMcePayloadType() ||

6358

DestType->isOCLIntelSubgroupAVCMceResultType())

6372 MultiExprArg

Args,

bool

TopLevelOfInitList,

bool

TreatUnavailableAsInvalid)

6376

TreatUnavailableAsInvalid);

6382 auto

*DRE = dyn_cast<DeclRefExpr>(

);

6383 if

(!DRE || !isa<FunctionDecl>(DRE->getDecl()))

6387

cast<FunctionDecl>(DRE->getDecl()));

6404 return

isa<DecompositionDecl>(Entity.

());

6430 bool

TopLevelOfInitList,

6431 bool

TreatUnavailableAsInvalid) {

6438 for

(

unsigned

I = 0,

= Args.size(); I !=

; ++I)

6439 if

(Args[I]->getType()->isNonOverloadPlaceholderType()) {

6446

Args[I] = result.

();

6468 if

(Args.size() == 1) {

6486

TreatUnavailableAsInvalid);

6497

(Var->

getLocation

(), diag::warn_field_requires_explicit_init)

6511 if

(Args.size() != 1)

6517 else if

(isa<InitListExpr>(Args[0]))

6521

TopLevelOfInitList);

6547 if

(

&& isa<VariableArrayType>(DestAT)) {

6579 if

(

&& isa<ConstantArrayType>(DestAT) &&

6584

TreatUnavailableAsInvalid);

6592

isa<CompoundLiteralExpr>(

->IgnoreParens()) &&

6610

this

, TreatUnavailableAsInvalid);

6612

}

else if

(S.

().CPlusPlus20 && !TopLevelOfInitList &&

6628 bool

allowObjCWritebackConversion = S.

().ObjCAutoRefCount &&

6637

assert(

"Initializer must be non-null"

);

6639 if

(allowObjCWritebackConversion &&

6665

SourceType, DestType))))) {

6672 if

(

const auto

*RD =

6677

().CPlusPlus20 && RD && RD->hasDefinition() &&

6678

RD->isAggregate() &&

Failed

() &&

6691

S, Kind.getLocation(), Best);

6709

assert(

"Initializer must be non-null"

);

6711

TopLevelOfInitList);

6716

assert(Args.size() >= 1 &&

"Zero-argument case handled above"

);

6722

(SourceType.

isNull

() ||

6726 for

(

auto

*Arg : Args) {

6727 if

(Arg->getType()->isExtVectorType()) {

6728 const auto

*VTy = Arg->getType()->castAs<

ExtVectorType

>();

6730 for

(

unsigned

Idx = 0; Idx < Elm; ++Idx) {

6736

VTy->getElementType(), Arg->

getValueKind

(), Arg->getObjectKind(),

6740

InitArgs.emplace_back(Arg);

6750 if

(Args.size() > 1) {

6753

}

else if

(isa<InitListExpr>(Args[0])) {

6761

assert(

"Initializer must be non-null"

);

6764 bool

NeedAtomicConversion =

false

;

6768 Atomic

->getValueType())) {

6769

DestType =

Atomic

->getValueType();

6770

NeedAtomicConversion =

true

;

6775

TopLevelOfInitList);

6777 if

Failed

() && NeedAtomicConversion)

6804

Sema::AllowedExplicit::None,

6806

Kind.isCStyleOrFunctionalCast(),

6807

allowObjCWritebackConversion);

6815 bool

ShouldCopy =

true

;

6831

}

else if

(ICS.

isBad

()) {

6839 else if

(

->getType()->isFunctionType() &&

6852 for

(

auto

&S : Steps)

6860 bool

Diagnose =

false

) {

6911

llvm_unreachable(

"Invalid EntityKind!"

);

6945

llvm_unreachable(

"missed an InitializedEntity kind?"

);

6979

llvm_unreachable(

"missed an InitializedEntity kind?"

);

7018

llvm_unreachable(

"missed an InitializedEntity kind?"

);

7045 bool

IsExtraneousCopy) {

7070

, CurInitExpr, CandidateSet,

, Ctors, Best,

7082

? diag::ext_rvalue_to_reference_temp_copy_no_viable

7083

: diag::err_temp_copy_no_viable)

7101

(

, diag::err_temp_copy_deleted)

7108 bool

HadMultipleCandidates = CandidateSet.

() > 1;

7117 if

(IsExtraneousCopy) {

7128 for

(

unsigned

I = 1, N = Constructor->getNumParams(); I != N; ++I) {

7131

diag::err_call_incomplete_argument))

7172

Best->Function->getParamDecl(0)->getType().getNonReferenceType(),

7177 Loc

, Best->FoundDecl, Constructor, Elidable, ConstructorArgs,

7178

HadMultipleCandidates,

7194 Expr

*CurInitExpr) {

7213

, CurInitExpr, CandidateSet, CurInitExpr->

(), Ctors, Best,

7226

Best->FoundDecl, Entity,

);

7247void

InitializationSequence::PrintInitLocationNote(

Sema

&S,

7262

diag::note_method_return_type_change)

7280 switch

(Kind.getKind()) {

7286 return

NumArgs != 1;

7298 bool

&ConstructorInitRequiresZeroInit,

7299 bool

IsListInitialization,

7300 bool

IsStdInitListInitialization,

7303 unsigned

NumArgs = Args.size();

7311

? Kind.getEqualLoc()

7312

: Kind.getLocation();

7318

assert(Constructor->getParent() &&

"No parent class for constructor."

);

7319 if

(Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&

7320

Constructor->isTrivial() && !Constructor->isUsed(

false

)) {

7335 bool

AllowExplicitConv =

7336

Kind.AllowExplicit() && !Kind.isCopyInit() && Args.size() == 1 &&

7341 if

(NumArgs == 1 && !Kind.isExplicitCast())

7343

Entity.

(), Args.front()->getType(), Kind.getLocation());

7348

ConstructorArgs, AllowExplicitConv,

7349

IsListInitialization))

7358

Constructor->isImplicit()) {

7363 if

(I >= ConstructorArgs.size() && FD->

hasAttr

<ExplicitInitAttr>()) {

7364

(

, diag::warn_field_requires_explicit_init)

7379

: Kind.getParenOrBraceRange();

7382 if

(

auto

*Shadow = dyn_cast<ConstructorUsingShadowDecl>(

7392

ConstructorArgs, ParenOrBraceRange, HadMultipleCandidates,

7393

IsListInitialization, IsStdInitListInitialization,

7394

ConstructorInitRequiresZeroInit),

7410 if

(IsListInitialization)

7411

ParenOrBraceRange =

(LBraceLoc, RBraceLoc);

7413

ParenOrBraceRange = Kind.getParenOrBraceRange();

7422

HadMultipleCandidates,

7423

IsListInitialization,

7424

IsStdInitListInitialization,

7425

ConstructorInitRequiresZeroInit,

7433

HadMultipleCandidates,

7434

IsListInitialization,

7435

IsStdInitListInitialization,

7436

ConstructorInitRequiresZeroInit,

7467 const Expr

*PostInit);

7474 bool

IsReturnStmt) {

7485 unsigned

DiagID = 0;

7488

dyn_cast<CXXConstructExpr>(InitExpr->

IgnoreParens

());

7515 if

(VD->

hasAttr

<BlocksAttr>())

7528 if

(isa<ParmVarDecl>(VD))

7529

DiagID = diag::warn_redundant_move_on_return;

7531

DiagID = diag::warn_pessimizing_move_on_return;

7533

DiagID = diag::warn_pessimizing_move_on_initialization;

7575 if

(UO->getOpcode() == UO_Deref &&

7576

UO->getSubExpr()->IgnoreParenCasts()->

7579

(diag::warn_binding_null_to_reference)

7580

<< UO->getSubExpr()->getSourceRange());

7586 bool

BoundToLvalueReference) {

7629 if

(!PointeeTy.isNull() &&

7630

PointeeTy.getAddressSpace() != ExprPointeeTy.getAddressSpace())

7631

CK = CK_AddressSpaceConversion;

7633

CK = CK_AddressSpaceConversion;

7648 if

(!ZeroInitializationFixit.empty()) {

7650 const auto

*VD = dyn_cast_or_null<VarDecl>(

);

7656 if

(!DestType->

isRecordType

() && VD && VD->isConstexpr()) {

7658

(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)

7661

ZeroInitializationFixit);

7663 unsigned

DiagID = diag::err_default_init_const;

7665

DiagID = diag::ext_default_init_const;

7667

(Kind.getLocation(), DiagID)

7670

ZeroInitializationFixit);

7690 if

(isa<InitListExpr>((

*)Args[0])) {

7694 if

(

auto

*DD = dyn_cast_or_null<DeclaratorDecl>(Entity.

())) {

7696 TypeLoc

TL = TInfo->getTypeLoc();

7699

Brackets = ArrayLoc.getBracketsRange();

7706

ArrayT->getSizeModifier(),

7707

ArrayT->getIndexTypeCVRQualifiers(),

7714

!Kind.isExplicitCast()) {

7716 SourceRange

ParenRange = Kind.getParenOrBraceRange();

7721

Kind.isExplicitCast() ||

7731

Args.size() == 1 && isa<InitListExpr>(Args[0]) &&

7737

(

->getBeginLoc(), diag::warn_cxx98_compat_reference_list_init)

7738

->getSourceRange();

7741 if

(S.

().MicrosoftExt && Args.size() == 1 &&

7747

(

->getBeginLoc(), diag::ext_init_from_predefined) <<

;

7758

(Args[0]->getBeginLoc(), diag::err_opencl_atomic_init)

7778

isa<InitListExpr>(Args[0]);

7779

(void)IsHLSLVectorInit;

7784 switch

(Steps.front().Kind) {

7818

assert(Args.size() == 1 || IsHLSLVectorInit);

7837

isa_and_nonnull<InitListExpr>(CurInit.

()));

7842 auto

checkAbstractType = [&](

QualType T

) ->

bool

{

7847

diag::err_allocation_of_abstract_type);

7852 bool

ConstructorInitRequiresZeroInit =

false

;

7885 bool

IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();

7897

CK_DerivedToBase, CurInit.

(),

7913 if

(

auto

*DRE = dyn_cast<DeclRefExpr>(CurInit.

()->

IgnoreParens

())) {

7914 if

(

auto

*FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {

7927

assert(CurInit.

()->

isPRValue

() &&

"not a temporary"

);

7959 if

(checkAbstractType(

))

7985 bool

CreatedObject =

false

;

8001 Loc

, FoundFn, Constructor, ConstructorArgs,

8002

HadMultipleCandidates,

8014 CastKind

= CK_ConstructorConversion;

8015

CreatedObject =

true

;

8025

HadMultipleCandidates);

8029 CastKind

= CK_UserDefinedConversion;

8033 if

(CreatedObject && checkAbstractType(CurInit.

()->

()))

8054

(diag::err_access_dtor_temp) <<

);

8078 "function reference should be lvalue"

);

8084

assert(CurInit.

()->

isPRValue

() &&

"cannot convert glvalue to atomic"

);

8092 if

(

const auto

*FromPtrType =

8095 if

(FromPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&

8096

!ToPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {

8099 if

(!Kind.isStaticCast()) {

8101

diag::warn_noderef_to_dereferenceable_pointer)

8120

CurInit = CurInitExprRes;

8131 if

(checkAbstractType(

))

8141

InitListChecker PerformInitList(S, InitEntity,

8142

InitList, Ty,

false

8144 if

(PerformInitList.HadError())

8152 if

((*ResultType)->isRValueReferenceType())

8154 else if

((*ResultType)->isLValueReferenceType())

8161

PerformInitList.getFullyStructuredList();

8165

: StructuredInitList;

8170 if

(checkAbstractType(

))

8182

assert(Args.size() == 1 &&

"expected a single argument for list init"

);

8184

(InitList->

(), diag::warn_cxx98_compat_ctor_list_init)

8190

ConstructorInitRequiresZeroInit,

8199

CurInit = cast<InitListExpr>(CurInit.

())->getInit(0);

8216 if

(checkAbstractType(

))

8228 bool

IsStdInitListInit =

8230 Expr

*Source = CurInit.

();

8232

? Kind.getParenOrBraceRange()

8235

S, UseTemporary ? TempEntity : Entity, Kind,

8237

ConstructorInitRequiresZeroInit,

8248 if

(NextStep != StepEnd &&

8253

ConstructorInitRequiresZeroInit =

true

;

8256

!Kind.isImplicitValueInit()) {

8260

Kind.getRange().getBegin());

8264

Kind.getRange().getEnd());

8281 if

(

.isInvalid())

8294

CurInit = CurInitExprRes;

8309

(Kind.getLocation(), diag::err_c23_constexpr_pointer_not_null);

8316

InitialCurInit.

(),

8319

PrintInitLocationNote(S, Entity);

8321

}

else if

(Complained)

8322

PrintInitLocationNote(S, Entity);

8338

CK_ObjCObjectLValueCast,

8350

BaseExpr, Kind.getLocation(), IndexExpr, Kind.getLocation());

8351

ArrayLoopCommonExprs.push_back(BaseExpr);

8356

assert(!ArrayLoopCommonExprs.empty() &&

8357 "mismatched SK_ArrayLoopIndex and SK_ArrayLoopInit"

);

8358 Expr

*Common = ArrayLoopCommonExprs.pop_back_val();

8367

(Kind.getLocation(), diag::ext_array_init_copy)

8381

IncompleteDest->getElementType(), ConstantSource->getSize(),

8391

(Kind.getLocation(), diag::ext_array_init_parens)

8411

diag::warn_cxx98_compat_initializer_list_init)

8424

[[maybe_unused]]

bool

IsStdInitializerList =

8426

assert(IsStdInitializerList &&

8427 "StdInitializerList step to non-std::initializer_list"

);

8431 "std::initializer_list should have already be " 8432 "complete/instantiated by this point"

);

8434 auto

InvalidType = [&] {

8436

diag::err_std_initializer_list_malformed)

8441 if

(

->isUnion() ||

->getNumBases() != 0 ||

8442 Record

->isPolymorphic())

8443 return

InvalidType();

8446 if

(Field ==

->field_end())

8447 return

InvalidType();

8450 if

(!Field->getType()->isPointerType() ||

8453 return

InvalidType();

8455 if

(++Field ==

->field_end())

8456 return

InvalidType();

8459 if

(

const auto

*PT = Field->getType()->getAs<

PointerType

>()) {

8462 return

InvalidType();

8464 if

(Field->isBitField() ||

8466 return

InvalidType();

8469 if

(++Field !=

->field_end())

8470 return

InvalidType();

8497 "Sampler initialization on non-sampler type."

);

8503

(Kind.getLocation(), diag::err_sampler_argument_required)

8507 auto

Var = cast<VarDecl>(DRE->getDecl());

8510 if

(!Var->hasGlobalStorage()) {

8522 if

(!Var->getInit() || !isa<ImplicitCastExpr>(Var->getInit()))

8524 Init

= cast<ImplicitCastExpr>(

const_cast<Expr

>

(

8525

Var->getInit()))->getSubExpr();

8526

SourceType =

->getType();

8533 if

->isConstantInitializer(S.

false

))

8538

(Kind.getLocation(), diag::err_sampler_initializer_not_integer)

8546 const

uint64_t SamplerValue =

.getLimitedValue();

8553 unsigned

AddressingMode = (0x0E & SamplerValue) >> 1;

8554 unsigned

FilterMode = (0x30 & SamplerValue) >> 4;

8555 if

(FilterMode != 1 && FilterMode != 2 &&

8557 "cl_intel_device_side_avc_motion_estimation"

, S.

()))

8558

(Kind.getLocation(),

8559

diag::warn_sampler_initializer_invalid_bits)

8561 if

(AddressingMode > 4)

8562

(Kind.getLocation(),

8563

diag::warn_sampler_initializer_invalid_bits)

8564

"Addressing Mode"

;

8570

CK_IntToOCLSampler);

8576 "Wrong type for initialization of OpenCL opaque type."

);

8579

CK_ZeroToOCLOpaqueType,

8587 if

(CurInit.

() && ResultType)

8608

cast<FieldDecl>(Entity.

())->isBitField())

8609

S.CheckBitFieldInitialization(Kind.getLocation(),

8624

(

, diag::err_reference_without_init)

8625

.getNonReferenceType();

8633 for

(

const auto

*FI : RD->

()) {

8634 if

(FI->isUnnamedBitField())

8638

(

, diag::note_value_initialization_here) << RD;

8643 for

(

const auto

&BI : RD->

bases

()) {

8645

(

, diag::note_value_initialization_here) << RD;

8680 if

(fromDecl && destDecl && fromDecl->getDeclKind() == Decl::CXXRecord &&

8681

destDecl->getDeclKind() == Decl::CXXRecord &&

8682

!fromDecl->isInvalidDecl() && !destDecl->isInvalidDecl() &&

8683

!fromDecl->hasDefinition() &&

8686

(fromDecl->getLocation(), diag::note_forward_class_conversion)

8714 if

(

auto

= Entity.

())

8716

(

, diag::note_in_reference_temporary_list_initializer) <<

;

8720

InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,

8723

assert(DiagnoseInitList.HadError() &&

8724 "Inconsistent init list check result."

);

8739 if

(Args.size() == 1) {

8740 auto

*List = dyn_cast<InitListExpr>(Args[0]);

8741 if

(List && List->getNumInits() == 1)

8742

OnlyArg = List->getInit(0);

8751 if

(

*Resolved =

8771

assert(Diagnosed &&

"couldn't find uninitialized reference to diagnose"

);

8774

(Kind.getLocation(), diag::err_reference_has_multiple_inits)

8775

(Args.front()->getBeginLoc(), Args.back()->getEndLoc());

8778

(Kind.getLocation(), diag::err_list_init_in_parens)

8779

<< 1 << Entity.

() << Args[0]->getSourceRange();

8783

(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;

8786

(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;

8789

(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;

8792

(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);

8795

(Kind.getLocation(), diag::err_array_init_wide_string_into_char);

8798

(Kind.getLocation(),

8799

diag::err_array_init_incompat_wide_string_into_wchar);

8802

(Kind.getLocation(),

8803

diag::err_array_init_plain_string_into_char8_t);

8804

(Args.front()->getBeginLoc(),

8805

diag::note_array_init_plain_string_into_char8_t)

8809

(Kind.getLocation(), diag::err_array_init_utf8_string_into_char)

8814

(Kind.getLocation(),

8816

? diag::err_array_init_different_type

8817

: diag::err_array_init_non_constant_array))

8820

<< Args[0]->getSourceRange();

8824

(Kind.getLocation(), diag::err_variable_object_no_init)

8825

<< Args[0]->getSourceRange();

8838 auto

*FD = cast<FunctionDecl>(cast<DeclRefExpr>(OnlyArg)->getDecl());

8846 switch

(FailedOverloadResult) {

8853

? (S.

(diag::err_typecheck_ambiguous_condition)

8854

<< OnlyArg->

() << DestType

8855

<< Args[0]->getSourceRange())

8856

: (S.

(diag::err_ref_init_ambiguous)

8857

<< DestType << OnlyArg->

()

8858

<< Args[0]->getSourceRange())),

8866

diag::err_typecheck_nonviable_condition_incomplete,

8867

OnlyArg->

(), Args[0]->getSourceRange()))

8868

(Kind.getLocation(), diag::err_typecheck_nonviable_condition)

8870

<< OnlyArg->

() << Args[0]->getSourceRange()

8882

(Kind.getLocation(), diag::err_typecheck_deleted_function)

8884

<< (Msg !=

nullptr

) << (Msg ? Msg->

getString

() : StringRef())

8885

<< Args[0]->getSourceRange();

8889

llvm_unreachable(

"Inconsistent overload resolution?"

);

8895

llvm_unreachable(

"Conversion did not fail!"

);

8900 if

(isa<InitListExpr>(Args[0])) {

8901

(Kind.getLocation(),

8902

diag::err_lvalue_reference_bind_to_initlist)

8905

<< Args[0]->getSourceRange();

8911

(Kind.getLocation(),

8913

? diag::err_lvalue_reference_bind_to_temporary

8914

: diag::err_lvalue_reference_bind_to_unrelated)

8918

<< Args[0]->getSourceRange();

8923 FieldDecl

*BitField = Args[0]->getSourceBitField();

8924

(Kind.getLocation(), diag::err_reference_bind_to_bitfield)

8927

<< (BitField !=

nullptr

)

8928

<< Args[0]->getSourceRange();

8935

(Kind.getLocation(), diag::err_reference_bind_to_vector_element)

8937

<< Args[0]->getSourceRange();

8941

(Kind.getLocation(), diag::err_reference_bind_to_matrix_element)

8946

(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)

8948

<< Args[0]->getSourceRange();

8952

(Kind.getLocation(), diag::err_reference_bind_temporary_addrspace)

8953

<< DestType << Args[0]->getSourceRange();

8964

(Kind.getLocation(), diag::err_reference_bind_drops_quals)

8965

<< NonRefType << SourceType << 1

8966

<< Args[0]->getSourceRange();

8968

(Kind.getLocation(), diag::err_reference_bind_drops_quals)

8969

<< NonRefType << SourceType << 0

8975

(Kind.getLocation(), diag::err_reference_bind_drops_quals)

8976

<< NonRefType << SourceType << 2

8977

<< Args[0]->getSourceRange();

8982

(Kind.getLocation(), diag::err_reference_bind_failed)

8987

<< Args[0]->getSourceRange();

8998

<< Args[0]->getSourceRange();

9000

(Kind.getLocation(), PDiag);

9012 auto

*InitList = dyn_cast<InitListExpr>(Args[0]);

9013 if

(InitList && InitList->getNumInits() >= 1) {

9014

R =

(InitList->getInit(0)->getEndLoc(), InitList->getEndLoc());

9016

assert(Args.size() > 1 &&

"Expected multiple initializers!"

);

9017

R =

(Args.front()->getEndLoc(), Args.back()->getEndLoc());

9021 if

(Kind.isCStyleOrFunctionalCast())

9022

(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)

9025

(Kind.getLocation(), diag::err_excess_initializers)

9031

(Kind.getLocation(), diag::err_list_init_in_parens)

9032

<< 0 << Entity.

() << Args[0]->getSourceRange();

9036

(Kind.getLocation(), diag::err_reference_bind_init_list)

9041

(Kind.getLocation(), diag::err_init_list_bad_dest_type)

9042

<< (DestType->

isRecordType

()) << DestType << Args[0]->getSourceRange();

9050 SourceRange

(Args.front()->getBeginLoc(), Args.back()->getEndLoc());

9053

assert(Args.size() == 1 &&

9054 "List construction from other than 1 argument."

);

9061 switch

(FailedOverloadResult) {

9065

(diag::err_ovl_ambiguous_init)

9066

<< DestType << ArgsRange),

9083 if

(

auto

Inherited = Constructor->getInheritedConstructor())

9084

InheritedFrom = Inherited.getShadowDecl()->getNominatedBaseClass();

9086

(Kind.getLocation(), diag::err_missing_default_ctor)

9087

<< (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)

9099

(Kind.getLocation(), diag::err_missing_default_ctor)

9100

<< (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)

9106

diag::note_member_declared_at);

9111

diag::note_previous_decl)

9120

(diag::err_ovl_no_viable_function_in_init)

9121

<< DestType << ArgsRange),

9130

(Kind.getLocation(), diag::err_ovl_deleted_init)

9131

<< DestType << ArgsRange;

9132

llvm_unreachable(

"Inconsistent overload resolution?"

);

9140

(Kind.getLocation(), diag::err_ovl_deleted_special_init)

9141

<< llvm::to_underlying(

9143

<< DestType << ArgsRange;

9146

(Kind.getLocation(), diag::err_ovl_deleted_init)

9147

<< DestType << (Msg !=

nullptr

)

9148

<< (Msg ? Msg->

getString

() : StringRef()) << ArgsRange;

9156

llvm_unreachable(

"Conversion did not fail!"

);

9168

(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)

9169

<< (Constructor->getInheritedConstructor() ? 2 :

9170

Constructor->isImplicit() ? 1 : 0)

9176

}

else if

(

const auto

*VD = dyn_cast_if_present<VarDecl>(Entity.

());

9177

VD && VD->isConstexpr()) {

9178

(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)

9181

(Kind.getLocation(), diag::err_default_init_const)

9188

diag::err_init_incomplete_type);

9204

(Kind.getLocation(), diag::err_selected_explicit_constructor)

9205

<< Args[0]->getSourceRange();

9210

assert(Ovl ==

OR_Success

"Inconsistent overload resolution"

);

9213

diag::note_explicit_ctor_deduction_guide_here) <<

false

;

9224

(Kind.getLocation(), diag::err_designated_init_for_non_aggregate)

9229

PrintInitLocationNote(S, Entity);

9236

OS <<

"Failed sequence: "

;

9239

OS <<

"too many initializers for reference"

;

9243

OS <<

"parenthesized list init for reference"

;

9247

OS <<

"array requires initializer list"

;

9251

OS <<

"address of unaddressable function was taken"

;

9255

OS <<

"array requires initializer list or string literal"

;

9259

OS <<

"array requires initializer list or wide string literal"

;

9263

OS <<

"narrow string into wide char array"

;

9267

OS <<

"wide string into char array"

;

9271

OS <<

"incompatible wide string into wide char array"

;

9275

OS <<

"plain string literal into char8_t array"

;

9279

OS <<

"u8 string literal into char array"

;

9283

OS <<

"array type mismatch"

;

9287

OS <<

"non-constant array initializer"

;

9291

OS <<

"address of overloaded function failed"

;

9295

OS <<

"overload resolution for reference initialization failed"

;

9299

OS <<

"non-const lvalue reference bound to temporary"

;

9303

OS <<

"non-const lvalue reference bound to bit-field"

;

9307

OS <<

"non-const lvalue reference bound to vector element"

;

9311

OS <<

"non-const lvalue reference bound to matrix element"

;

9315

OS <<

"non-const lvalue reference bound to unrelated type"

;

9319

OS <<

"rvalue reference bound to an lvalue"

;

9323

OS <<

"reference initialization drops qualifiers"

;

9327

OS <<

"reference with mismatching address space bound to temporary"

;

9331

OS <<

"reference initialization failed"

;

9335

OS <<

"conversion failed"

;

9339

OS <<

"conversion from property failed"

;

9343

OS <<

"too many initializers for scalar"

;

9347

OS <<

"parenthesized list init for reference"

;

9351

OS <<

"referencing binding to initializer list"

;

9355

OS <<

"initializer list for non-aggregate, non-scalar type"

;

9359

OS <<

"overloading failed for user-defined conversion"

;

9363

OS <<

"constructor overloading failed"

;

9367

OS <<

"default initialization of a const variable"

;

9371

OS <<

"initialization of incomplete type"

;

9375

OS <<

"list initialization checker failure"

;

9379

OS <<

"variable length array has an initializer"

;

9383

OS <<

"initializer expression isn't contextually valid"

;

9387

OS <<

"list constructor overloading failed"

;

9391

OS <<

"list copy initialization chose explicit constructor"

;

9395

OS <<

"parenthesized list initialization failed"

;

9399

OS <<

"designated initializer for non-aggregate type"

;

9407

OS <<

"Dependent sequence\n"

;

9411

OS <<

"Normal sequence: "

;

9422

OS <<

"resolve address of overloaded function"

;

9426

OS <<

"derived-to-base (prvalue)"

;

9430

OS <<

"derived-to-base (xvalue)"

;

9434

OS <<

"derived-to-base (lvalue)"

;

9438

OS <<

"bind reference to lvalue"

;

9442

OS <<

"bind reference to a temporary"

;

9446

OS <<

"final copy in class direct-initialization"

;

9450

OS <<

"extraneous C++03 copy to temporary"

;

9454

OS <<

"user-defined conversion via "

<< *S->Function.Function;

9458

OS <<

"qualification conversion (prvalue)"

;

9462

OS <<

"qualification conversion (xvalue)"

;

9466

OS <<

"qualification conversion (lvalue)"

;

9470

OS <<

"function reference conversion"

;

9474

OS <<

"non-atomic-to-atomic conversion"

;

9478

OS <<

"implicit conversion sequence ("

;

9484

OS <<

"implicit conversion sequence with narrowing prohibited ("

;

9490

OS <<

"list aggregate initialization"

;

9494

OS <<

"unwrap reference initializer list"

;

9498

OS <<

"rewrap reference initializer list"

;

9502

OS <<

"constructor initialization"

;

9506

OS <<

"list initialization via constructor"

;

9510

OS <<

"zero initialization"

;

9514

OS <<

"C assignment"

;

9518

OS <<

"string initialization"

;

9522

OS <<

"Objective-C object conversion"

;

9526

OS <<

"indexing for array initialization loop"

;

9530

OS <<

"array initialization loop"

;

9534

OS <<

"array initialization"

;

9538

OS <<

"array initialization (GNU extension)"

;

9542

OS <<

"parenthesized array initialization"

;

9546

OS <<

"pass by indirect copy and restore"

;

9550

OS <<

"pass by indirect restore"

;

9554

OS <<

"Objective-C object retension"

;

9558

OS <<

"std::initializer_list from initializer list"

;

9562

OS <<

"list initialization from std::initializer_list"

;

9566

OS <<

"OpenCL sampler_t from integer constant"

;

9570

OS <<

"OpenCL opaque type from zero"

;

9573

OS <<

"initialization from a parenthesized list of values"

;

9577

OS <<

" ["

<< S->Type <<

']'

;

9584 dump

(llvm::errs());

9591 const Expr

*PostInit) {

9607 auto

MakeDiag = [&](

bool

IsConstRef,

unsigned

DefaultDiagID,

9608 unsigned

ConstRefDiagID,

unsigned

WarnDiagID) {

9611 if

(L.CPlusPlus11 && !L.HLSL &&

9613

DiagID = IsConstRef ? ConstRefDiagID : DefaultDiagID;

9615

DiagID = WarnDiagID;

9635

MakeDiag(

!= EntityType, diag::ext_init_list_type_narrowing,

9636

diag::ext_init_list_type_narrowing_const_reference,

9637

diag::warn_init_list_type_narrowing)

9639

.getLocalUnqualifiedType();

9646

diag::ext_init_list_constant_narrowing,

9647

diag::ext_init_list_constant_narrowing_const_reference,

9648

diag::warn_init_list_constant_narrowing)

9657

diag::ext_init_list_variable_narrowing,

9658

diag::ext_init_list_variable_narrowing_const_reference,

9659

diag::warn_init_list_variable_narrowing)

9667

llvm::raw_svector_ostream OS(StaticCast);

9668

OS <<

"static_cast<"

;

9675

OS << *TT->getDecl();

9684

(PostInit->

(), diag::note_init_list_narrowing_silence)

9695 Init

->IgnoreParenImpCasts(), ToType,

false

9696

Sema::AllowedExplicit::None,

9712

(

->getBeginLoc(), diag::err_c23_constexpr_init_not_representable)

9713

Value

.getAsString(S.

, PreNarrowingType) << ToType;

9718

(

->getBeginLoc(), diag::err_c23_constexpr_init_type_mismatch)

9719

<< ToType << FromType;

9729

llvm_unreachable(

"unhandled case in switch"

);

9741 for

(

unsigned

I = 0, N = SE->

getLength

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

9746

diag::err_c23_constexpr_init_not_representable)

9760 if

(

.isInvalid())

9764

assert(InitE &&

"No initialization expression"

);

9769 return

.Failed();

9776 bool

TopLevelOfInitList,

9777 bool

AllowExplicit) {

9778 if

(

.isInvalid())

9782

assert(InitE &&

"No initialization expression?"

);

9792 const bool

ShouldTrackCopy =

9794 if

(ShouldTrackCopy) {

9796 Seq

.SetOverloadFailure(

9802 const auto

LastStep =

.step_end() - 1;

9803

assert(LastStep->Kind ==

9807

llvm::find_if(

.getFailedCandidateSet(),

9809

return Candidate.Viable &&

9810

Candidate.Function == Function &&

9811

Candidate.Conversions.size() > 0;

9813 if

(Candidate !=

.getFailedCandidateSet().end() &&

9815

Candidate->

Viable

false

;

9819 Function

->getParamDecl(0)->getType());

9827 if

(ShouldTrackCopy)

9836 auto

NotSpecialization = [&] (

const CXXRecordDecl

*Candidate) {

9837 auto

*CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Candidate);

9840 return

!(NotSpecialization(RD) && RD->

forallBases

(NotSpecialization));

9846 auto

*DeducedTST = dyn_cast<DeducedTemplateSpecializationType>(

9848

assert(DeducedTST &&

"not a deduced template specialization type"

);

9859 if

(

auto

AliasTemplate

= dyn_cast_or_null<TypeAliasTemplateDecl>(

9861 Diag

(Kind.getLocation(),

9862

diag::warn_cxx17_compat_ctad_for_alias_templates);

9865

->getUnderlyingType()

9866

.getCanonicalType();

9870 if

(

const auto

*TST =

9872

Template = dyn_cast_or_null<ClassTemplateDecl>(

9873

TST->getTemplateName().getAsTemplateDecl());

9874

}

else if

(

const auto

*RT = UnderlyingType->getAs<

RecordType

>()) {

9878 if

(

const auto

*CTSD = llvm::dyn_cast<ClassTemplateSpecializationDecl>(

9879

RT->getAsCXXRecordDecl()))

9880

Template = CTSD->getSpecializedTemplate();

9885 Diag

(Kind.getLocation(),

9886

diag::err_deduced_non_class_or_alias_template_specialization_type)

9896

diag::warn_cxx14_compat_class_template_argument_deduction)

9924

? dyn_cast<InitListExpr>(Inits[0])

9940 bool

AllowExplicit = !Kind.isCopyInit() ||

;

9946 bool

OnlyListConstructors,

9947 bool

AllowAggregateDeductionCandidate) {

9953 if

(!AllowExplicit) {

9960 if

(GD->getMinRequiredArguments() > 1 ||

9961

(GD->getNumParams() == 0 && !GD->isVariadic()))

9971 if

(!AllowAggregateDeductionCandidate &&

9986 for

(

: Inits)

9987 if

(

auto

*DI = dyn_cast<DesignatedInitExpr>(

))

9988

TmpInits.push_back(DI->getInit());

9990

TmpInits.push_back(

);

9992

TD, FoundDecl,

nullptr

, TmpInits, Candidates,

9994 false

, AllowExplicit, ADLCallKind::NotADL,

9995

{}, AllowAggregateDeductionCandidate);

9999 false

, AllowExplicit);

10003 bool

FoundDeductionGuide =

false

;

10005 auto

TryToResolveOverload =

10008 bool

HasAnyDeductionGuide =

false

;

10011 auto

*Pattern = Template;

10012 while

(Pattern->getInstantiatedFromMemberTemplate()) {

10013 if

(Pattern->isMemberSpecialization())

10015

Pattern = Pattern->getInstantiatedFromMemberTemplate();

10018 auto

*RD = cast<CXXRecordDecl>(Pattern->getTemplatedDecl());

10024

InitListChecker CheckInitList(*

this

, Entity,

, Ty, ElementTypes);

10025 if

(!CheckInitList.HadError()) {

10034 for

(

int

I = 0,

->getNumInits();

10035

I <

&& !isa<PackExpansionType>(ElementTypes[I]); ++I)

10036 if

(ElementTypes[I]->isArrayType()) {

10037 if

(isa<InitListExpr, DesignatedInitExpr>(

->getInit(I)))

10039 else if

(isa<StringLiteral>(

10040 ListInit

->getInit(I)->IgnoreParenImpCasts()))

10047

LookupTemplateDecl, ElementTypes,

10051

OnlyListConstructors,

10053

HasAnyDeductionGuide =

true

;

10058 for

(

auto

I = Guides.

begin

(),

= Guides.

end

(); I !=

; ++I) {

10063 auto

*TD = dyn_cast<FunctionTemplateDecl>(

);

10064 auto

*GD = dyn_cast_if_present<CXXDeductionGuideDecl>(

10069 if

(!GD->isImplicit())

10070

HasAnyDeductionGuide =

true

;

10072

addDeductionCandidate(TD, GD, I.getPair(), OnlyListConstructors,

10087

}

else if

(Inits.size()) {

10092

Inits, Inits.back()->getEndLoc());

10093

SynthesizeAggrGuide(&TempListInit);

10097

FoundDeductionGuide = FoundDeductionGuide || HasAnyDeductionGuide;

10107 bool

TryListConstructors =

true

;

10113 auto

*FD = dyn_cast<FunctionDecl>(

->getUnderlyingDecl());

10114 if

(FD && FD->getMinRequiredArguments() == 0) {

10115

TryListConstructors =

false

;

10119

}

else if

(

->getNumInits() == 1) {

10127 if

(!isa<InitListExpr>(

) && RD &&

10130

TryListConstructors =

false

;

10133 if

(TryListConstructors)

10134 Result

= TryToResolveOverload(

true

);

10143 Result

= TryToResolveOverload(

false

);

10152

Kind.getLocation(),

10153 PDiag

(diag::err_deduced_class_template_ctor_ambiguous)

10160

cast<ClassTemplateDecl>(Template)->getTemplatedDecl();

10165

Kind.getLocation(),

10166 PDiag

(

Complete

? diag::err_deduced_class_template_ctor_no_viable

10167

: diag::err_deduced_class_template_incomplete)

10177 Diag

(Kind.getLocation(), diag::err_deduced_class_template_deleted)

10187 if

(Kind.isCopyInit() &&