28#include "llvm/ADT/APInt.h"
29#include "llvm/ADT/FoldingSet.h"
30#include "llvm/ADT/PointerIntPair.h"
31#include "llvm/ADT/SmallString.h"
32#include "llvm/ADT/SmallVector.h"
33#include "llvm/ADT/StringExtras.h"
34#include "llvm/Support/ErrorHandling.h"
35#include "llvm/Support/raw_ostream.h"
71 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
75 Init = Init->IgnoreParens();
89 auto IsCharOrUnsignedChar = [](
const QualType &T) {
90 const BuiltinType *BT = dyn_cast<BuiltinType>(T.getTypePtr());
148 assert(
false &&
"Unevaluated string literal in initialization");
152 llvm_unreachable(
"missed a StringLiteral kind?");
173 if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E)) {
175 }
else if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
176 E = PE->getSubExpr();
178 assert(UO->getOpcode() == UO_Extension);
179 E = UO->getSubExpr();
181 E = GSE->getResultExpr();
182 }
else if (
ChooseExpr *CE = dyn_cast<ChooseExpr>(E)) {
183 E = CE->getChosenSubExpr();
185 E = PE->getFunctionName();
187 llvm_unreachable(
"unexpected expr in string literal init");
197 if (isa<CompoundLiteralExpr>(E)) {
199 }
else if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
200 E = PE->getSubExpr();
202 assert(UO->getOpcode() == UO_Extension);
203 E = UO->getSubExpr();
205 E = GSE->getResultExpr();
206 }
else if (
ChooseExpr *CE = dyn_cast<ChooseExpr>(E)) {
207 E = CE->getChosenSubExpr();
209 llvm_unreachable(
"unexpected expr in array compound literal init");
217 auto *ConstantArrayTy =
219 uint64_t StrLength = ConstantArrayTy->getSize().getZExtValue();
224 llvm::APInt ConstVal(32, StrLength);
249 if (StrLength > CAT->
getSize().getZExtValue())
251 diag::err_initializer_string_for_char_array_too_long)
252 << CAT->
getSize().getZExtValue() << StrLength
256 if (StrLength-1 > CAT->
getSize().getZExtValue())
258 diag::ext_initializer_string_for_char_array_too_long)
306class InitListChecker {
308 bool hadError =
false;
310 bool TreatUnavailableAsInvalid;
311 bool InOverloadResolution;
325 unsigned &StructuredIndex);
329 bool TopLevelObject =
false);
332 bool SubobjectIsDesignatorContext,
335 unsigned &StructuredIndex,
336 bool TopLevelObject =
false);
341 unsigned &StructuredIndex,
342 bool DirectlyDesignated =
false);
347 unsigned &StructuredIndex);
352 unsigned &StructuredIndex);
357 unsigned &StructuredIndex);
361 unsigned &StructuredIndex);
366 bool SubobjectIsDesignatorContext,
unsigned &Index,
368 unsigned &StructuredIndex,
369 bool TopLevelObject =
false);
372 llvm::APSInt elementIndex,
373 bool SubobjectIsDesignatorContext,
unsigned &Index,
375 unsigned &StructuredIndex);
381 llvm::APSInt *NextElementIndex,
384 unsigned &StructuredIndex,
385 bool FinishSubobjectInit,
386 bool TopLevelObject);
390 unsigned StructuredIndex,
392 bool IsFullyOverwritten =
false);
393 void UpdateStructuredListElement(
InitListExpr *StructuredList,
394 unsigned &StructuredIndex,
398 unsigned ExpectedNumInits);
399 int numArrayElements(
QualType DeclType);
400 int numStructUnionElements(
QualType DeclType);
408 bool UnionOverride =
false,
409 bool FullyOverwritten =
true) {
414 ? (UnionOverride ? diag::ext_initializer_union_overrides
415 : diag::ext_initializer_overrides)
416 : diag::warn_initializer_overrides;
418 if (InOverloadResolution && SemaRef.
getLangOpts().CPlusPlus) {
439 DiagID = diag::err_initializer_overrides_destructed;
459 << NewInitRange << FullyOverwritten << OldInit->
getType();
488 bool FillWithNoInit);
489 void FillInEmptyInitForField(
unsigned Init,
FieldDecl *Field,
492 bool FillWithNoInit =
false);
496 bool FillWithNoInit =
false);
499 bool TopLevelObject);
506 bool VerifyOnly,
bool TreatUnavailableAsInvalid,
507 bool InOverloadResolution =
false,
512 : InitListChecker(S, Entity, IL, T,
true,
515 &AggrDeductionCandidateParamTypes){};
517 bool HadError() {
return hadError; }
521 InitListExpr *getFullyStructuredList()
const {
return FullyStructuredList; }
538 bool EmptyInitList = SemaRef.
getLangOpts().CPlusPlus11 &&
551 InitExpr = VerifyOnly
569 if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
573 InitSeq.getFailedCandidateSet()
574 .BestViableFunction(SemaRef,
Kind.getLocation(), Best);
576 assert(O ==
OR_Success &&
"Inconsistent overload resolution");
583 bool IsInStd =
false;
585 ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
590 if (IsInStd && llvm::StringSwitch<bool>(R->
getName())
591 .Cases(
"basic_string",
"deque",
"forward_list",
true)
592 .Cases(
"list",
"map",
"multimap",
"multiset",
true)
593 .Cases(
"priority_queue",
"queue",
"set",
"stack",
true)
594 .Cases(
"unordered_map",
"unordered_set",
"vector",
true)
596 InitSeq.InitializeFrom(
600 TreatUnavailableAsInvalid);
605 diag::warn_invalid_initializer_from_system_header);
608 diag::note_used_in_initialization_here);
610 SemaRef.
Diag(Loc, diag::note_used_in_initialization_here);
617 InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
620 diag::note_in_omitted_aggregate_initializer)
623 bool IsTrailingArrayNewMember =
626 SemaRef.
Diag(Loc, diag::note_in_omitted_aggregate_initializer)
627 << (IsTrailingArrayNewMember ? 2 : 0)
636 : InitSeq.Perform(SemaRef, Entity,
Kind, SubInit);
644 if (FullyStructuredList)
646 PerformEmptyInit(Loc, Entity);
649void InitListChecker::FillInEmptyInitForBase(
652 bool &RequiresSecondPass,
bool FillWithNoInit) {
659 : PerformEmptyInit(ILE->
getEndLoc(), BaseEntity);
666 assert(Init < ILE->getNumInits() &&
"should have been expanded");
670 dyn_cast<InitListExpr>(ILE->
getInit(Init))) {
671 FillInEmptyInitializations(BaseEntity, InnerILE, RequiresSecondPass,
672 ILE, Init, FillWithNoInit);
674 dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(Init))) {
675 FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),
676 RequiresSecondPass, ILE, Init,
681void InitListChecker::FillInEmptyInitForField(
unsigned Init,
FieldDecl *Field,
684 bool &RequiresSecondPass,
685 bool FillWithNoInit) {
691 if (Init >= NumInits || !ILE->
getInit(Init)) {
693 if (!RType->getDecl()->isUnion())
694 assert((Init < NumInits || VerifyOnly) &&
695 "This ILE should have been expanded");
697 if (FillWithNoInit) {
698 assert(!VerifyOnly &&
"should not fill with no-init in verify-only mode");
710 if (
Field->hasInClassInitializer()) {
724 RequiresSecondPass =
true;
729 if (
Field->getType()->isReferenceType()) {
735 SemaRef.
Diag(Loc, diag::err_init_reference_member_uninitialized)
739 SemaRef.
Diag(
Field->getLocation(), diag::note_uninit_reference_member);
745 ExprResult MemberInit = PerformEmptyInit(Loc, MemberEntity);
751 if (hadError || VerifyOnly) {
753 }
else if (Init < NumInits) {
755 }
else if (!isa<ImplicitValueInitExpr>(MemberInit.
get())) {
761 RequiresSecondPass =
true;
764 = dyn_cast<InitListExpr>(ILE->
getInit(Init))) {
765 FillInEmptyInitializations(MemberEntity, InnerILE,
766 RequiresSecondPass, ILE, Init, FillWithNoInit);
768 dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(Init))) {
769 FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
770 RequiresSecondPass, ILE, Init,
781 bool &RequiresSecondPass,
784 bool FillWithNoInit) {
786 "Should not have void type");
790 if (FillWithNoInit && VerifyOnly)
800 struct UpdateOuterILEWithUpdatedInit {
803 ~UpdateOuterILEWithUpdatedInit() {
807 } UpdateOuterRAII = {OuterILE, OuterIndex};
818 Entity, ILE, RequiresSecondPass, FillWithNoInit);
819 else if (RDecl->
isUnion() && isa<CXXRecordDecl>(RDecl) &&
820 cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
821 for (
auto *Field : RDecl->
fields()) {
822 if (
Field->hasInClassInitializer()) {
823 FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass,
832 unsigned NumElems = numStructUnionElements(ILE->
getType());
840 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {
841 for (
auto &
Base : CXXRD->bases()) {
845 FillInEmptyInitForBase(Init,
Base, Entity, ILE, RequiresSecondPass,
851 for (
auto *Field : RDecl->
fields()) {
852 if (
Field->isUnnamedBitfield())
858 FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass,
878 unsigned NumElements = NumInits;
880 ElementType = AType->getElementType();
881 if (
const auto *CAType = dyn_cast<ConstantArrayType>(AType))
882 NumElements = CAType->getSize().getZExtValue();
890 ElementType = VType->getElementType();
891 NumElements = VType->getNumElements();
897 bool SkipEmptyInitChecks =
false;
898 for (
unsigned Init = 0; Init != NumElements; ++Init) {
906 if (Init >= NumInits && (ILE->
hasArrayFiller() || SkipEmptyInitChecks))
909 Expr *InitExpr = (Init < NumInits ? ILE->
getInit(Init) :
nullptr);
910 if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
915 if (SkipEmptyInitChecks)
918 Expr *Filler =
nullptr;
924 PerformEmptyInit(ILE->
getEndLoc(), ElementEntity);
935 }
else if (VerifyOnly) {
936 SkipEmptyInitChecks =
true;
937 }
else if (Init < NumInits) {
952 if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {
958 RequiresSecondPass =
true;
962 = dyn_cast_or_null<InitListExpr>(InitExpr)) {
963 FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
964 ILE, Init, FillWithNoInit);
966 dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr)) {
967 FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
968 RequiresSecondPass, ILE, Init,
975 for (
const Stmt *Init : *IL)
976 if (isa_and_nonnull<DesignatedInitExpr>(Init))
981InitListChecker::InitListChecker(
983 bool VerifyOnly,
bool TreatUnavailableAsInvalid,
bool InOverloadResolution,
985 : SemaRef(S), VerifyOnly(VerifyOnly),
986 TreatUnavailableAsInvalid(TreatUnavailableAsInvalid),
987 InOverloadResolution(InOverloadResolution),
988 AggrDeductionCandidateParamTypes(AggrDeductionCandidateParamTypes) {
990 FullyStructuredList =
999 CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
1002 if (!hadError && !AggrDeductionCandidateParamTypes && FullyStructuredList) {
1003 bool RequiresSecondPass =
false;
1004 FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass,
1006 if (RequiresSecondPass && !hadError)
1007 FillInEmptyInitializations(Entity, FullyStructuredList,
1008 RequiresSecondPass,
nullptr, 0);
1010 if (hadError && FullyStructuredList)
1014int InitListChecker::numArrayElements(
QualType DeclType) {
1016 int maxElements = 0x7FFFFFFF;
1019 maxElements =
static_cast<int>(CAT->getSize().getZExtValue());
1024int InitListChecker::numStructUnionElements(
QualType DeclType) {
1026 int InitializableMembers = 0;
1027 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl))
1028 InitializableMembers += CXXRD->getNumBases();
1029 for (
const auto *Field : structDecl->
fields())
1030 if (!
Field->isUnnamedBitfield())
1031 ++InitializableMembers;
1034 return std::min(InitializableMembers, 1);
1040 return RT->getDecl();
1042 return Inject->getDecl();
1072 if (
CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(ParentRD)) {
1073 if (CXXRD->getNumBases()) {
1077 auto FieldIt = ParentRD->field_begin();
1078 assert(FieldIt != ParentRD->field_end() &&
1079 "no fields but have initializer for member?");
1080 return ++FieldIt == ParentRD->field_end();
1096 unsigned &StructuredIndex) {
1097 int maxElements = 0;
1100 maxElements = numArrayElements(T);
1102 maxElements = numStructUnionElements(T);
1106 llvm_unreachable(
"CheckImplicitInitList(): Illegal type");
1108 if (maxElements == 0) {
1111 diag::err_implicit_empty_initializer);
1118 InitListExpr *StructuredSubobjectInitList = getStructuredSubobjectInit(
1119 ParentIList, Index, T, StructuredList, StructuredIndex,
1122 unsigned StructuredSubobjectInitIndex = 0;
1125 unsigned StartIndex = Index;
1126 CheckListElementTypes(Entity, ParentIList, T,
1128 StructuredSubobjectInitList,
1129 StructuredSubobjectInitIndex);
1131 if (StructuredSubobjectInitList) {
1132 StructuredSubobjectInitList->
setType(T);
1134 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
1137 if (EndIndex < ParentIList->getNumInits() &&
1138 ParentIList->
getInit(EndIndex)) {
1149 diag::warn_missing_braces)
1155 StructuredSubobjectInitList->
getEndLoc()),
1161 if (!VerifyOnly && CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1163 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1179 unsigned DiagID = 0;
1191 DiagID = diag::warn_braces_around_init;
1198 DiagID = diag::warn_braces_around_init;
1224 llvm_unreachable(
"unexpected braced scalar init");
1243 bool TopLevelObject) {
1244 unsigned Index = 0, StructuredIndex = 0;
1245 CheckListElementTypes(Entity, IList, T,
true,
1246 Index, StructuredList, StructuredIndex, TopLevelObject);
1247 if (StructuredList) {
1253 StructuredList->
setType(ExprTy);
1261 bool ExtraInitsIsError = SemaRef.
getLangOpts().CPlusPlus ||
1263 hadError = ExtraInitsIsError;
1266 }
else if (StructuredIndex == 1 &&
1271 ? diag::err_excess_initializers_in_char_array_initializer
1272 : diag::ext_excess_initializers_in_char_array_initializer;
1276 unsigned DK = ExtraInitsIsError
1277 ? diag::err_excess_initializers_for_sizeless_type
1278 : diag::ext_excess_initializers_for_sizeless_type;
1288 unsigned DK = ExtraInitsIsError ? diag::err_excess_initializers
1289 : diag::ext_excess_initializers;
1297 !isa<InitListExpr>(IList->
getInit(0)))
1303 if (CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1306 bool HasEquivCtor =
false;
1312 if (!HasEquivCtor) {
1314 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1324 bool SubobjectIsDesignatorContext,
1327 unsigned &StructuredIndex,
1328 bool TopLevelObject) {
1332 CheckComplexType(Entity, IList, DeclType, Index,
1333 StructuredList, StructuredIndex);
1335 CheckScalarType(Entity, IList, DeclType, Index,
1336 StructuredList, StructuredIndex);
1338 CheckVectorType(Entity, IList, DeclType, Index,
1339 StructuredList, StructuredIndex);
1340 }
else if (
const RecordDecl *RD = getRecordDecl(DeclType)) {
1346 "non-aggregate records should be handed in CheckSubElementType");
1347 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1348 Bases = CXXRD->bases();
1350 Bases = cast<CXXRecordDecl>(RD)->bases();
1352 CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(),
1353 SubobjectIsDesignatorContext, Index, StructuredList,
1354 StructuredIndex, TopLevelObject);
1359 CheckArrayType(Entity, IList, DeclType, Zero,
1360 SubobjectIsDesignatorContext, Index,
1361 StructuredList, StructuredIndex);
1366 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1370 CheckReferenceType(Entity, IList, DeclType, Index,
1371 StructuredList, StructuredIndex);
1374 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_init_objc_class) << DeclType;
1379 CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1386 assert(AggrDeductionCandidateParamTypes);
1387 AggrDeductionCandidateParamTypes->push_back(DeclType);
1390 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1401 unsigned &StructuredIndex,
1402 bool DirectlyDesignated) {
1406 return CheckReferenceType(Entity, IList, ElemType, Index,
1407 StructuredList, StructuredIndex);
1410 if (SubInitList->getNumInits() == 1 &&
1415 expr = SubInitList->getInit(0);
1418 }
else if (isa<ImplicitValueInitExpr>(
expr)) {
1422 "found implicit initialization for the wrong type");
1423 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1445 if (TmpEntity.getType()->isDependentType()) {
1450 assert(AggrDeductionCandidateParamTypes);
1451 if (!isa_and_nonnull<ConstantArrayType>(
1454 AggrDeductionCandidateParamTypes->push_back(ElemType);
1466 if (Seq || isa<InitListExpr>(
expr)) {
1469 if (Result.isInvalid())
1472 UpdateStructuredListElement(StructuredList, StructuredIndex,
1473 Result.getAs<
Expr>());
1476 }
else if (StructuredList) {
1477 UpdateStructuredListElement(StructuredList, StructuredIndex,
1481 if (AggrDeductionCandidateParamTypes)
1482 AggrDeductionCandidateParamTypes->push_back(ElemType);
1490 return CheckScalarType(Entity, IList, ElemType, Index,
1491 StructuredList, StructuredIndex);
1503 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1532 UpdateStructuredListElement(StructuredList, StructuredIndex,
1550 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
1555 if (DirectlyDesignated && SemaRef.
getLangOpts().CPlusPlus && !hadError) {
1556 if (InOverloadResolution)
1560 diag::ext_designated_init_brace_elision)
1561 <<
expr->getSourceRange()
1576 assert(
Copy.isInvalid() &&
1577 "expected non-aggregate initialization to fail");
1589 unsigned &StructuredIndex) {
1590 assert(Index == 0 &&
"Index in explicit init list must be zero");
1600 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1605 if (!SemaRef.
getLangOpts().CPlusPlus && !VerifyOnly)
1614 for (
unsigned i = 0; i < 2; ++i) {
1616 CheckSubElementType(ElementEntity, IList, elementType, Index,
1617 StructuredList, StructuredIndex);
1625 unsigned &StructuredIndex) {
1632 ? diag::warn_cxx98_compat_empty_sizeless_initializer
1633 : diag::err_empty_sizeless_initializer)
1638 ? diag::warn_cxx98_compat_empty_scalar_initializer
1639 : diag::err_empty_scalar_initializer)
1655 SemaRef.
Diag(SubIList->getBeginLoc(), diag::ext_many_braces_around_init)
1658 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1661 }
else if (isa<DesignatedInitExpr>(
expr)) {
1664 diag::err_designator_for_scalar_or_sizeless_init)
1666 <<
expr->getSourceRange();
1676 Result = getDummyInit();
1685 Expr *ResultExpr =
nullptr;
1687 if (Result.isInvalid())
1690 ResultExpr = Result.getAs<
Expr>();
1692 if (ResultExpr !=
expr && !VerifyOnly) {
1695 IList->
setInit(Index, ResultExpr);
1698 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1700 if (AggrDeductionCandidateParamTypes)
1701 AggrDeductionCandidateParamTypes->push_back(DeclType);
1708 unsigned &StructuredIndex) {
1716 diag::err_init_reference_member_uninitialized)
1738 Result = getDummyInit();
1747 if (Result.isInvalid())
1752 if (!VerifyOnly &&
expr)
1755 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1757 if (AggrDeductionCandidateParamTypes)
1758 AggrDeductionCandidateParamTypes->push_back(DeclType);
1765 unsigned &StructuredIndex) {
1768 unsigned numEltsInit = 0;
1773 CheckEmptyInitializable(
1783 if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
1787 Result = getDummyInit();
1796 Expr *ResultExpr =
nullptr;
1797 if (Result.isInvalid())
1800 ResultExpr = Result.getAs<
Expr>();
1802 if (ResultExpr != Init && !VerifyOnly) {
1805 IList->
setInit(Index, ResultExpr);
1808 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1810 if (AggrDeductionCandidateParamTypes)
1811 AggrDeductionCandidateParamTypes->push_back(elementType);
1818 for (
unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1821 CheckEmptyInitializable(ElementEntity, IList->
getEndLoc());
1826 CheckSubElementType(ElementEntity, IList, elementType, Index,
1827 StructuredList, StructuredIndex);
1848 diag::warn_neon_vector_initializer_non_portable);
1850 const char *typeCode;
1860 llvm_unreachable(
"Invalid element type!");
1864 ? diag::note_neon_vector_initializer_non_portable_q
1865 : diag::note_neon_vector_initializer_non_portable)
1866 << typeCode << typeSize;
1876 for (
unsigned i = 0; i < maxElements; ++i) {
1885 CheckSubElementType(ElementEntity, IList, elementType, Index,
1886 StructuredList, StructuredIndex);
1898 CheckSubElementType(ElementEntity, IList, VecType, Index,
1899 StructuredList, StructuredIndex);
1900 numEltsInit += numIElts;
1905 if (numEltsInit != maxElements) {
1908 diag::err_vector_incorrect_num_initializers)
1909 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1932 SemaRef.
PDiag(diag::err_access_dtor_temp)
1940 llvm::APSInt elementIndex,
1941 bool SubobjectIsDesignatorContext,
1944 unsigned &StructuredIndex) {
1956 if (Index < IList->getNumInits()) {
1967 if (StructuredList) {
1968 UpdateStructuredListElement(StructuredList, StructuredIndex,
1973 if (AggrDeductionCandidateParamTypes)
1974 AggrDeductionCandidateParamTypes->push_back(DeclType);
1995 SemaRef.
Diag(VAT->getSizeExpr()->getBeginLoc(),
1996 diag::err_variable_object_no_init)
1997 << VAT->getSizeExpr()->getSourceRange();
2006 llvm::APSInt maxElements(elementIndex.getBitWidth(),
2007 elementIndex.isUnsigned());
2008 bool maxElementsKnown =
false;
2010 maxElements = CAT->getSize();
2011 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
2012 elementIndex.setIsUnsigned(maxElements.isUnsigned());
2013 maxElementsKnown =
true;
2017 while (Index < IList->getNumInits()) {
2023 if (!SubobjectIsDesignatorContext)
2028 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
2029 DeclType,
nullptr, &elementIndex, Index,
2030 StructuredList, StructuredIndex,
true,
2036 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
2037 maxElements = maxElements.extend(elementIndex.getBitWidth());
2038 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
2039 elementIndex = elementIndex.extend(maxElements.getBitWidth());
2040 elementIndex.setIsUnsigned(maxElements.isUnsigned());
2044 if (!maxElementsKnown && elementIndex > maxElements)
2045 maxElements = elementIndex;
2052 if (maxElementsKnown && elementIndex == maxElements)
2059 CheckSubElementType(ElementEntity, IList, elementType, Index,
2060 StructuredList, StructuredIndex);
2065 if (!maxElementsKnown && elementIndex > maxElements)
2066 maxElements = elementIndex;
2071 llvm::APSInt
Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
2075 SemaRef.
Diag(IList->
getBeginLoc(), diag::ext_typecheck_zero_array_size);
2086 if ((maxElementsKnown && elementIndex < maxElements) ||
2088 CheckEmptyInitializable(
2097 bool TopLevelObject) {
2099 unsigned FlexArrayDiag;
2100 if (isa<InitListExpr>(InitExpr) &&
2101 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
2103 FlexArrayDiag = diag::ext_flexible_array_init;
2104 }
else if (!TopLevelObject) {
2106 FlexArrayDiag = diag::err_flexible_array_init;
2109 FlexArrayDiag = diag::err_flexible_array_init;
2110 }
else if (cast<VarDecl>(Entity.
getDecl())->hasLocalStorage()) {
2112 FlexArrayDiag = diag::err_flexible_array_init;
2115 FlexArrayDiag = diag::ext_flexible_array_init;
2121 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2125 return FlexArrayDiag != diag::ext_flexible_array_init;
2128void InitListChecker::CheckStructUnionTypes(
2131 bool SubobjectIsDesignatorContext,
unsigned &Index,
2132 InitListExpr *StructuredList,
unsigned &StructuredIndex,
2133 bool TopLevelObject) {
2134 const RecordDecl *RD = getRecordDecl(DeclType);
2156 if (isa<CXXRecordDecl>(RD) &&
2157 cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
2158 if (!StructuredList)
2161 Field != FieldEnd; ++Field) {
2162 if (
Field->hasInClassInitializer()) {
2173 Field != FieldEnd; ++Field) {
2174 if (!
Field->isUnnamedBitfield()) {
2175 CheckEmptyInitializable(
2186 bool InitializedSomething =
false;
2189 for (
auto I = Bases.begin(), E = Bases.end(); I != E; ++I) {
2195 if (Init && isa<DesignatedInitExpr>(Init))
2212 if (AggrDeductionCandidateParamTypes &&
Base.isPackExpansion()) {
2213 AggrDeductionCandidateParamTypes->push_back(
2218 if (Index < IList->getNumInits())
2230 CheckSubElementType(BaseEntity, IList,
Base.getType(), Index,
2231 StructuredList, StructuredIndex);
2232 InitializedSomething =
true;
2234 CheckEmptyInitializable(BaseEntity, InitLoc);
2249 size_t NumRecordDecls = llvm::count_if(RD->
decls(), [&](
const Decl *D) {
2250 return isa<FieldDecl>(D) || isa<RecordDecl>(D);
2252 bool CheckForMissingFields =
2254 bool HasDesignatedInit =
false;
2258 while (Index < IList->getNumInits()) {
2266 if (!SubobjectIsDesignatorContext)
2269 HasDesignatedInit =
true;
2273 bool DesignatedInitFailed = CheckDesignatedInitializer(
2274 Entity, IList, DIE, 0, DeclType, &Field,
nullptr, Index,
2275 StructuredList, StructuredIndex,
true, TopLevelObject);
2276 if (DesignatedInitFailed)
2283 InitializedFields.insert(F);
2284 if (!DesignatedInitFailed) {
2293 InitializedSomething =
true;
2298 CheckForMissingFields =
false;
2315 if (NumRecordDecls == 1)
2317 if (
const auto *IL = dyn_cast<IntegerLiteral>(I))
2318 return IL->getValue().isZero();
2326 SemaRef.
Diag(InitLoc, diag::err_non_designated_init_used);
2331 if (Field == FieldEnd) {
2337 if (InitializedSomething && RD->
isUnion())
2341 if (
Field->getType()->isIncompleteArrayType())
2344 if (
Field->isUnnamedBitfield()) {
2353 InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
2374 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2375 StructuredList, StructuredIndex);
2376 InitializedSomething =
true;
2377 InitializedFields.insert(*Field);
2379 if (RD->
isUnion() && StructuredList) {
2388 if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
2396 if (HasDesignatedInit && InitializedFields.count(*it))
2399 if (!it->isUnnamedBitfield() && !it->hasInClassInitializer() &&
2400 !it->getType()->isIncompleteArrayType()) {
2402 diag::warn_missing_field_initializers)
2411 if (!StructuredList && Field != FieldEnd && !RD->
isUnion() &&
2412 !
Field->getType()->isIncompleteArrayType()) {
2413 for (;
Field != FieldEnd && !hadError; ++
Field) {
2414 if (!
Field->isUnnamedBitfield() && !
Field->hasInClassInitializer())
2415 CheckEmptyInitializable(
2436 if (Field == FieldEnd || !
Field->getType()->isIncompleteArrayType() ||
2440 if (CheckFlexibleArrayInit(Entity, IList->
getInit(Index), *Field,
2450 if (isa<InitListExpr>(IList->
getInit(Index)) ||
2451 AggrDeductionCandidateParamTypes)
2452 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2453 StructuredList, StructuredIndex);
2455 CheckImplicitInitList(MemberEntity, IList,
Field->getType(), Index,
2456 StructuredList, StructuredIndex);
2472 PE = IndirectField->
chain_end(); PI != PE; ++PI) {
2480 assert(isa<FieldDecl>(*PI));
2481 Replacements.back().setFieldDecl(cast<FieldDecl>(*PI));
2488 &Replacements[0] + Replacements.size());
2495 for (
unsigned I = 0; I < NumIndexExprs; ++I)
2509 explicit FieldInitializerValidatorCCC(
const RecordDecl *RD)
2517 std::unique_ptr<CorrectionCandidateCallback>
clone()
override {
2518 return std::make_unique<FieldInitializerValidatorCCC>(*
this);
2571 llvm::APSInt *NextElementIndex,
2574 unsigned &StructuredIndex,
2575 bool FinishSubobjectInit,
2576 bool TopLevelObject) {
2577 if (DesigIdx == DIE->
size()) {
2584 assert(isa<InitListExpr>(Init) &&
2585 "designator result in direct non-list initialization?");
2587 DIE->
getBeginLoc(), Init->getBeginLoc(), Init->getEndLoc());
2590 if (StructuredList) {
2593 : Seq.Perform(SemaRef, Entity,
Kind, Init);
2594 UpdateStructuredListElement(StructuredList, StructuredIndex,
2598 if (AggrDeductionCandidateParamTypes)
2599 AggrDeductionCandidateParamTypes->push_back(CurrentObjectType);
2604 bool prevHadError = hadError;
2609 unsigned OldIndex = Index;
2612 CheckSubElementType(Entity, IList, CurrentObjectType, Index, StructuredList,
2613 StructuredIndex,
true);
2619 IList->
setInit(OldIndex, DIE);
2621 return hadError && !prevHadError;
2625 bool IsFirstDesignator = (DesigIdx == 0);
2626 if (IsFirstDesignator ? FullyStructuredList : StructuredList) {
2629 if (IsFirstDesignator)
2630 StructuredList = FullyStructuredList;
2632 Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2633 StructuredList->getInit(StructuredIndex) :
nullptr;
2634 if (!ExistingInit && StructuredList->hasArrayFiller())
2635 ExistingInit = StructuredList->getArrayFiller();
2638 StructuredList = getStructuredSubobjectInit(
2639 IList, Index, CurrentObjectType, StructuredList, StructuredIndex,
2641 else if (
InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2642 StructuredList = Result;
2655 diagnoseInitOverride(ExistingInit,
2662 dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2663 StructuredList = E->getUpdater();
2668 StructuredList->updateInit(SemaRef.
Context, StructuredIndex, DIUE);
2677 StructuredList =
nullptr;
2693 RecordDecl *RD = getRecordDecl(CurrentObjectType);
2699 SemaRef.
Diag(Loc, diag::err_field_designator_non_aggr)
2700 << SemaRef.
getLangOpts().CPlusPlus << CurrentObjectType;
2709 if (
auto *FD = dyn_cast_if_present<FieldDecl>(VD)) {
2711 }
else if (
auto *IFD = dyn_cast_if_present<IndirectFieldDecl>(VD)) {
2717 KnownField = cast<FieldDecl>(*IFD->chain_begin());
2736 SemaRef.
Diag(Lookup.front()->getLocation(),
2737 diag::note_field_designator_found);
2744 FieldInitializerValidatorCCC CCC(RD);
2751 SemaRef.
PDiag(diag::err_field_designator_unknown_suggest)
2752 << FieldName << CurrentObjectType);
2753 KnownField = Corrected.getCorrectionDeclAs<
FieldDecl>();
2764 SemaRef.
Diag(Loc, diag::err_field_designator_unknown)
2772 unsigned NumBases = 0;
2773 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2774 NumBases = CXXRD->getNumBases();
2776 unsigned FieldIndex = NumBases;
2778 for (
auto *FI : RD->
fields()) {
2779 if (FI->isUnnamedBitfield())
2795 if (StructuredList) {
2796 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2798 assert(StructuredList->getNumInits() == 1
2799 &&
"A union should never have more than one initializer!");
2801 Expr *ExistingInit = StructuredList->getInit(0);
2804 diagnoseInitOverride(
2812 StructuredList->resizeInits(SemaRef.
Context, 0);
2813 StructuredList->setInitializedFieldInUnion(
nullptr);
2816 StructuredList->setInitializedFieldInUnion(*Field);
2823 InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
2846 if (IsFirstDesignator && !VerifyOnly && SemaRef.
getLangOpts().CPlusPlus &&
2849 (*NextField)->getFieldIndex() >
Field->getFieldIndex() + 1)) {
2853 if (FI->isUnnamedBitfield())
2864 diag::ext_designated_init_reordered)
2867 unsigned OldIndex = StructuredIndex - 1;
2868 if (StructuredList && OldIndex <= StructuredList->getNumInits()) {
2869 if (
Expr *PrevInit = StructuredList->getInit(OldIndex)) {
2870 SemaRef.
Diag(PrevInit->getBeginLoc(),
2871 diag::note_previous_field_init)
2885 if (StructuredList && FieldIndex >= StructuredList->getNumInits())
2886 StructuredList->resizeInits(SemaRef.
Context, FieldIndex + 1);
2889 if (
Field->getType()->isIncompleteArrayType()) {
2891 if ((DesigIdx + 1) != DIE->
size()) {
2898 diag::err_designator_into_flexible_array_member)
2900 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2906 if (!hadError && !isa<InitListExpr>(DIE->
getInit()) &&
2907 !isa<StringLiteral>(DIE->
getInit())) {
2911 diag::err_flexible_array_init_needs_braces)
2913 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2920 if (!
Invalid && CheckFlexibleArrayInit(Entity, DIE->
getInit(), *Field,
2930 bool prevHadError = hadError;
2931 unsigned newStructuredIndex = FieldIndex;
2932 unsigned OldIndex = Index;
2937 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2938 StructuredList, newStructuredIndex);
2940 IList->
setInit(OldIndex, DIE);
2941 if (hadError && !prevHadError) {
2946 StructuredIndex = FieldIndex;
2952 unsigned newStructuredIndex = FieldIndex;
2956 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2957 FieldType,
nullptr,
nullptr, Index,
2958 StructuredList, newStructuredIndex,
2959 FinishSubobjectInit,
false))
2970 if (IsFirstDesignator) {
2977 StructuredIndex = FieldIndex;
2981 if (!FinishSubobjectInit)
2989 bool prevHadError = hadError;
2994 CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,
2995 false, Index, StructuredList, FieldIndex);
2996 return hadError && !prevHadError;
3018 << CurrentObjectType;
3023 Expr *IndexExpr =
nullptr;
3024 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
3028 DesignatedEndIndex = DesignatedStartIndex;
3032 DesignatedStartIndex =
3034 DesignatedEndIndex =
3043 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
3048 if (isa<ConstantArrayType>(AT)) {
3049 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(),
false);
3050 DesignatedStartIndex
3051 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
3052 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
3054 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
3055 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
3056 if (DesignatedEndIndex >= MaxElements) {
3059 diag::err_array_designator_too_large)
3066 unsigned DesignatedIndexBitWidth =
3068 DesignatedStartIndex =
3069 DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
3070 DesignatedEndIndex =
3071 DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
3072 DesignatedStartIndex.setIsUnsigned(
true);
3073 DesignatedEndIndex.setIsUnsigned(
true);
3076 bool IsStringLiteralInitUpdate =
3077 StructuredList && StructuredList->isStringLiteralInit();
3078 if (IsStringLiteralInitUpdate && VerifyOnly) {
3081 StructuredList =
nullptr;
3082 }
else if (IsStringLiteralInitUpdate) {
3095 unsigned PromotedCharTyWidth = Context.
getTypeSize(PromotedCharTy);
3100 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
3101 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
3102 StructuredList->resizeInits(Context, StrLen);
3106 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
3107 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
3109 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
3110 if (CharTy != PromotedCharTy)
3114 StructuredList->updateInit(Context, i, Init);
3123 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
3124 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
3125 StructuredList->resizeInits(Context, StrLen);
3129 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
3130 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
3132 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
3133 if (CharTy != PromotedCharTy)
3137 StructuredList->updateInit(Context, i, Init);
3144 if (StructuredList &&
3145 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
3146 StructuredList->resizeInits(SemaRef.
Context,
3147 DesignatedEndIndex.getZExtValue() + 1);
3153 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
3154 unsigned OldIndex = Index;
3159 while (DesignatedStartIndex <= DesignatedEndIndex) {
3165 if (CheckDesignatedInitializer(
3166 ElementEntity, IList, DIE, DesigIdx + 1, ElementType,
nullptr,
3167 nullptr, Index, StructuredList, ElementIndex,
3168 FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),
3173 ++DesignatedStartIndex;
3174 ElementIndex = DesignatedStartIndex.getZExtValue();
3179 if (IsFirstDesignator) {
3180 if (NextElementIndex)
3181 *NextElementIndex = DesignatedStartIndex;
3182 StructuredIndex = ElementIndex;
3186 if (!FinishSubobjectInit)
3190 bool prevHadError = hadError;
3191 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
3193 StructuredList, ElementIndex);
3194 return hadError && !prevHadError;
3200InitListChecker::getStructuredSubobjectInit(
InitListExpr *IList,
unsigned Index,
3203 unsigned StructuredIndex,
3205 bool IsFullyOverwritten) {
3206 if (!StructuredList)
3209 Expr *ExistingInit =
nullptr;
3210 if (StructuredIndex < StructuredList->getNumInits())
3211 ExistingInit = StructuredList->
getInit(StructuredIndex);
3213 if (
InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
3222 if (!IsFullyOverwritten)
3245 diagnoseInitOverride(ExistingInit, InitRange);
3248 unsigned ExpectedNumInits = 0;
3249 if (Index < IList->getNumInits()) {
3250 if (
auto *Init = dyn_cast_or_null<InitListExpr>(IList->
getInit(Index)))
3251 ExpectedNumInits = Init->getNumInits();
3257 createInitListExpr(CurrentObjectType, InitRange, ExpectedNumInits);
3266InitListChecker::createInitListExpr(
QualType CurrentObjectType,
3268 unsigned ExpectedNumInits) {
3272 QualType ResultType = CurrentObjectType;
3275 Result->setType(ResultType);
3278 unsigned NumElements = 0;
3283 NumElements = CAType->getSize().getZExtValue();
3286 if (NumElements > ExpectedNumInits)
3290 NumElements = VType->getNumElements();
3292 NumElements = numStructUnionElements(CurrentObjectType);
3297 Result->reserveInits(SemaRef.
Context, NumElements);
3304void InitListChecker::UpdateStructuredListElement(
InitListExpr *StructuredList,
3305 unsigned &StructuredIndex,
3308 if (!StructuredList)
3312 StructuredIndex,
expr)) {
3318 diagnoseInitOverride(PrevInit,
expr->getSourceRange());
3329 InitListChecker Check(*
this, Entity, From,
Type,
true,
3332 return !Check.HadError();
3353 return S.
Diag(Loc, diag::err_array_designator_negative)
3356 Value.setIsUnsigned(
true);
3375 Designators.push_back(ASTDesignator::CreateFieldDesignator(
3379 llvm::APSInt IndexValue;
3380 if (!Index->isTypeDependent() && !Index->isValueDependent())
3385 Designators.push_back(ASTDesignator::CreateArrayDesignator(
3387 InitExpressions.push_back(Index);
3392 llvm::APSInt StartValue;
3393 llvm::APSInt EndValue;
3398 if (!StartDependent)
3404 if (!StartIndex || !EndIndex)
3408 if (StartDependent || EndDependent) {
3410 }
else if (StartValue.getBitWidth() > EndValue.getBitWidth())
3411 EndValue = EndValue.extend(StartValue.getBitWidth());
3412 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
3413 StartValue = StartValue.extend(EndValue.getBitWidth());
3415 if (!StartDependent && !EndDependent && EndValue < StartValue) {
3421 Designators.push_back(ASTDesignator::CreateArrayRangeDesignator(
3424 InitExpressions.push_back(StartIndex);
3425 InitExpressions.push_back(EndIndex);
3431 if (
Invalid || Init.isInvalid())
3435 EqualOrColonLoc, GNUSyntax,
3436 Init.getAs<
Expr>());
3443InitializedEntity::InitializedEntity(
ASTContext &Context,
unsigned Index,
3448 Kind = EK_ArrayElement;
3451 Kind = EK_VectorElement;
3455 assert(CT &&
"Unexpected type");
3456 Kind = EK_ComplexElement;
3464 bool IsInheritedVirtualBase,
3469 Result.Base = {
Base, IsInheritedVirtualBase};
3487 return Variable.VariableOrMember->getDeclName();
3509 llvm_unreachable(
"Invalid EntityKind!");
3543 llvm_unreachable(
"Invalid EntityKind!");
3578unsigned InitializedEntity::dumpImpl(raw_ostream &OS)
const {
3581 for (
unsigned I = 0; I != Depth; ++I)
3598 case EK_New: OS <<
"New";
break;
3602 case EK_Base: OS <<
"Base";
break;
3609 OS <<
"Block (lambda)";
3612 OS <<
"LambdaCapture ";
3619 D->printQualifiedName(OS);
3622 OS <<
" '" <<
getType() <<
"'\n";
3628 dumpImpl(llvm::errs());
3683 for (
const Step &S : llvm::reverse(Steps)) {
3743 llvm_unreachable(
"Invalid EntityKind!");
3751InitializationSequence
3752::AddAddressOverloadResolutionStep(
FunctionDecl *Function,
3754 bool HadMultipleCandidates) {
3757 S.Type = Function->getType();
3758 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3759 S.Function.Function = Function;
3760 S.Function.FoundDecl = Found;
3779 bool BindingTemporary) {
3804 bool HadMultipleCandidates) {
3808 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3809 S.Function.Function = Function;
3810 S.Function.FoundDecl = FoundDecl;
3849 bool TopLevelOfInitList) {
3867 bool HadMultipleCandidates,
bool FromInitList,
bool AsInitList) {
3873 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3874 S.Function.Function = Constructor;
3875 S.Function.FoundDecl = FoundDecl;
3918 Steps.insert(Steps.begin(), S);
3979 "Can only rewrap trivial init lists.");
3983 Steps.insert(Steps.begin(), S);
3987 S.WrappingSyntacticList = Syntactic;
3994 this->Failure = Failure;
3995 this->FailedOverloadResult =
Result;
4016 if (!Init.empty()) {
4036 "consuming an object of unretainable type?");
4057 bool TreatUnavailableAsInvalid);
4068 bool TreatUnavailableAsInvalid) {
4082 List->getNumInits()),
4087 List->getExprLoc(), List->getBeginLoc(), List->getEndLoc());
4089 TreatUnavailableAsInvalid);
4119 bool CopyInitializing,
bool AllowExplicit,
4120 bool OnlyListConstructors,
bool IsListInit,
4121 bool SecondStepOfCopyInit =
false) {
4127 if (!Info.Constructor || Info.Constructor->isInvalidDecl())
4144 bool SuppressUserConversions =
4145 SecondStepOfCopyInit ||
4146 (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
4149 if (Info.ConstructorTmpl)
4151 Info.ConstructorTmpl, Info.FoundDecl,
4152 nullptr, Args, CandidateSet, SuppressUserConversions,
4153 false, AllowExplicit);
4162 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
4166 CandidateSet, SuppressUserConversions,
4167 false, AllowExplicit,
4183 if (S.
getLangOpts().CPlusPlus17 && Args.size() == 1 &&
4184 !SecondStepOfCopyInit) {
4186 auto *SourceRD =
Initializer->getType()->getAsCXXRecordDecl();
4188 const auto &Conversions = SourceRD->getVisibleConversionFunctions();
4189 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4199 Conv = cast<CXXConversionDecl>(D);
4203 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4204 CandidateSet, AllowExplicit, AllowExplicit,
4208 DestType, CandidateSet, AllowExplicit,
4235 bool IsListInit =
false,
4236 bool IsInitListCopy =
false) {
4237 assert(((!IsListInit && !IsInitListCopy) ||
4238 (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
4239 "IsListInit/IsInitListCopy must come with a single initializer list "
4242 (IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) :
nullptr;
4266 UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isPRValue() &&
4276 assert(DestRecordType &&
"Constructor initialization requires record type");
4278 = cast<CXXRecordDecl>(DestRecordType->
getDecl());
4286 bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
4296 bool AsInitializerList =
false;
4308 AsInitializerList =
true;
4314 CandidateSet, DestType, Ctors, Best,
4315 CopyInitialization, AllowExplicit,
4326 AsInitializerList =
false;
4328 CandidateSet, DestType, Ctors, Best,
4329 CopyInitialization, AllowExplicit,
4343 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4347 if (
auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
4349 QualType ConvType = CD->getConversionType();
4351 "should not have selected this conversion function");
4353 HadMultipleCandidates);
4384 if (IsListInit && !Kind.AllowExplicit() && CtorDecl->
isExplicit()) {
4404 Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,
4405 IsListInit | IsInitListCopy, AsInitializerList);
4418 bool HadMultipleCandidates =
false;
4421 UnqualifiedTargetType,
4423 &HadMultipleCandidates)) {
4425 HadMultipleCandidates);
4426 SourceType = Fn->getType();
4458 bool TreatUnavailableAsInvalid) {
4498 T1Quals, cv2T2, T2, T2Quals, Sequence);
4528 TreatUnavailableAsInvalid);
4560 bool TreatUnavailableAsInvalid) {
4572 TreatUnavailableAsInvalid);
4610 !IsDesignatedInit) {
4615 Expr *InitListAsExpr = InitList;
4625 if (!isa<VariableArrayType>(DestAT) &&
4635 TreatUnavailableAsInvalid);
4668 TreatUnavailableAsInvalid))
4672 Expr *InitListAsExpr = InitList;
4674 DestType, Sequence,
true);
4692 ET && ET->getDecl()->isFixed() &&
4741 if (Init->getType()->isRecordType() ||
4742 (Init->getType()->isNullPtrType() && DestType->
isBooleanType())) {
4749 Expr *SubInit[1] = { Init };
4752 TreatUnavailableAsInvalid);
4759 InitListChecker CheckInitList(S, Entity, InitList,
4760 DestType,
true, TreatUnavailableAsInvalid);
4761 if (CheckInitList.HadError()) {
4783 "Must have incompatible references when binding via conversion");
4794 bool AllowExplicitCtors =
false;
4795 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
4806 if (!Info.Constructor)
4809 if (!Info.Constructor->isInvalidDecl() &&
4810 Info.Constructor->isConvertingConstructor(
true)) {
4811 if (Info.ConstructorTmpl)
4813 Info.ConstructorTmpl, Info.FoundDecl,
4816 false, AllowExplicitCtors);
4819 Info.Constructor, Info.FoundDecl,
Initializer, CandidateSet,
4821 false, AllowExplicitCtors);
4836 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4839 if (isa<UsingShadowDecl>(D))
4840 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4847 Conv = cast<CXXConversionDecl>(D);
4855 if ((AllowRValues ||
4859 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4861 false, AllowExplicitConvs);
4864 Conv, I.getPair(), ActingDC,
Initializer, DestType, CandidateSet,
4865 false, AllowExplicitConvs);
4883 Function->setReferenced();
4887 if (isa<CXXConversionDecl>(Function))
4888 cv3T3 = Function->getReturnType();
4900 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4902 HadMultipleCandidates);
4912 assert(!isa<CXXConstructorDecl>(Function) &&
4913 "should not have conversion after constructor");
4917 ICS.
Standard = Best->FinalConversion;
4938 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
4940 else if (RefConv & Sema::ReferenceConversions::ObjC)
4942 else if (RefConv & Sema::ReferenceConversions::Function)
4944 else if (RefConv & Sema::ReferenceConversions::Qualification) {
4979 T1Quals, cv2T2, T2, T2Quals, Sequence);
5026 if (isLValueRef || T1Function) {
5029 (Kind.isCStyleOrFunctionalCast() &&
5033 if (RefConv & (Sema::ReferenceConversions::DerivedToBase |
5034 Sema::ReferenceConversions::ObjC)) {
5037 if (RefConv & (Sema::ReferenceConversions::Qualification))
5041 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
5045 }
else if (RefConv & Sema::ReferenceConversions::Qualification) {
5049 }
else if (RefConv & Sema::ReferenceConversions::Function) {
5069 (isLValueRef || InitCategory.
isRValue())) {
5074 isLValueRef, Sequence);