26#include "llvm/ADT/APInt.h"
27#include "llvm/ADT/PointerIntPair.h"
28#include "llvm/ADT/SmallString.h"
29#include "llvm/Support/ErrorHandling.h"
30#include "llvm/Support/raw_ostream.h"
66 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
70 Init = Init->IgnoreParens();
84 auto IsCharOrUnsignedChar = [](
const QualType &T) {
85 const BuiltinType *BT = dyn_cast<BuiltinType>(T.getTypePtr());
144 llvm_unreachable(
"missed a StringLiteral kind?");
165 if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E)) {
167 }
else if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
168 E = PE->getSubExpr();
170 assert(UO->getOpcode() == UO_Extension);
171 E = UO->getSubExpr();
173 E = GSE->getResultExpr();
174 }
else if (
ChooseExpr *CE = dyn_cast<ChooseExpr>(E)) {
175 E = CE->getChosenSubExpr();
177 llvm_unreachable(
"unexpected expr in string literal init");
187 if (isa<CompoundLiteralExpr>(E)) {
189 }
else if (
ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
190 E = PE->getSubExpr();
192 assert(UO->getOpcode() == UO_Extension);
193 E = UO->getSubExpr();
195 E = GSE->getResultExpr();
196 }
else if (
ChooseExpr *CE = dyn_cast<ChooseExpr>(E)) {
197 E = CE->getChosenSubExpr();
199 llvm_unreachable(
"unexpected expr in array compound literal init");
207 auto *ConstantArrayTy =
209 uint64_t StrLength = ConstantArrayTy->getSize().getZExtValue();
214 llvm::APInt ConstVal(32, StrLength);
239 if (StrLength > CAT->
getSize().getZExtValue())
241 diag::err_initializer_string_for_char_array_too_long)
242 << CAT->
getSize().getZExtValue() << StrLength
246 if (StrLength-1 > CAT->
getSize().getZExtValue())
248 diag::ext_initializer_string_for_char_array_too_long)
296class InitListChecker {
298 bool hadError =
false;
300 bool TreatUnavailableAsInvalid;
301 bool InOverloadResolution;
314 unsigned &StructuredIndex);
318 bool TopLevelObject =
false);
321 bool SubobjectIsDesignatorContext,
324 unsigned &StructuredIndex,
325 bool TopLevelObject =
false);
330 unsigned &StructuredIndex,
331 bool DirectlyDesignated =
false);
336 unsigned &StructuredIndex);
341 unsigned &StructuredIndex);
346 unsigned &StructuredIndex);
350 unsigned &StructuredIndex);
355 bool SubobjectIsDesignatorContext,
unsigned &Index,
357 unsigned &StructuredIndex,
358 bool TopLevelObject =
false);
361 llvm::APSInt elementIndex,
362 bool SubobjectIsDesignatorContext,
unsigned &Index,
364 unsigned &StructuredIndex);
370 llvm::APSInt *NextElementIndex,
373 unsigned &StructuredIndex,
374 bool FinishSubobjectInit,
375 bool TopLevelObject);
379 unsigned StructuredIndex,
381 bool IsFullyOverwritten =
false);
382 void UpdateStructuredListElement(
InitListExpr *StructuredList,
383 unsigned &StructuredIndex,
387 unsigned ExpectedNumInits);
388 int numArrayElements(
QualType DeclType);
389 int numStructUnionElements(
QualType DeclType);
396 bool FullyOverwritten =
true) {
400 ? diag::ext_initializer_overrides
401 : diag::warn_initializer_overrides;
403 if (InOverloadResolution && SemaRef.
getLangOpts().CPlusPlus) {
424 DiagID = diag::err_initializer_overrides_destructed;
444 << NewInitRange << FullyOverwritten << OldInit->
getType();
473 bool FillWithNoInit);
474 void FillInEmptyInitForField(
unsigned Init,
FieldDecl *Field,
477 bool FillWithNoInit =
false);
481 bool FillWithNoInit =
false);
484 bool TopLevelObject);
490 QualType &T,
bool VerifyOnly,
bool TreatUnavailableAsInvalid,
491 bool InOverloadResolution =
false);
492 bool HadError() {
return hadError; }
496 InitListExpr *getFullyStructuredList()
const {
return FullyStructuredList; }
513 bool EmptyInitList = SemaRef.
getLangOpts().CPlusPlus11 &&
526 InitExpr = VerifyOnly
544 if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
548 InitSeq.getFailedCandidateSet()
549 .BestViableFunction(SemaRef,
Kind.getLocation(), Best);
551 assert(O ==
OR_Success &&
"Inconsistent overload resolution");
558 bool IsInStd =
false;
560 ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
565 if (IsInStd && llvm::StringSwitch<bool>(R->
getName())
566 .Cases(
"basic_string",
"deque",
"forward_list",
true)
567 .Cases(
"list",
"map",
"multimap",
"multiset",
true)
568 .Cases(
"priority_queue",
"queue",
"set",
"stack",
true)
569 .Cases(
"unordered_map",
"unordered_set",
"vector",
true)
571 InitSeq.InitializeFrom(
575 TreatUnavailableAsInvalid);
580 diag::warn_invalid_initializer_from_system_header);
583 diag::note_used_in_initialization_here);
585 SemaRef.
Diag(Loc, diag::note_used_in_initialization_here);
592 InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
595 diag::note_in_omitted_aggregate_initializer)
598 bool IsTrailingArrayNewMember =
601 SemaRef.
Diag(Loc, diag::note_in_omitted_aggregate_initializer)
602 << (IsTrailingArrayNewMember ? 2 : 0)
611 : InitSeq.Perform(SemaRef, Entity,
Kind, SubInit);
619 if (FullyStructuredList)
621 PerformEmptyInit(Loc, Entity);
624void InitListChecker::FillInEmptyInitForBase(
627 bool &RequiresSecondPass,
bool FillWithNoInit) {
634 : PerformEmptyInit(ILE->
getEndLoc(), BaseEntity);
641 assert(Init < ILE->getNumInits() &&
"should have been expanded");
645 dyn_cast<InitListExpr>(ILE->
getInit(Init))) {
646 FillInEmptyInitializations(BaseEntity, InnerILE, RequiresSecondPass,
647 ILE, Init, FillWithNoInit);
649 dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(Init))) {
650 FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),
651 RequiresSecondPass, ILE, Init,
656void InitListChecker::FillInEmptyInitForField(
unsigned Init,
FieldDecl *Field,
659 bool &RequiresSecondPass,
660 bool FillWithNoInit) {
666 if (Init >= NumInits || !ILE->
getInit(Init)) {
668 if (!RType->getDecl()->isUnion())
669 assert((Init < NumInits || VerifyOnly) &&
670 "This ILE should have been expanded");
672 if (FillWithNoInit) {
673 assert(!VerifyOnly &&
"should not fill with no-init in verify-only mode");
685 if (
Field->hasInClassInitializer()) {
699 RequiresSecondPass =
true;
704 if (
Field->getType()->isReferenceType()) {
710 SemaRef.
Diag(Loc, diag::err_init_reference_member_uninitialized)
714 SemaRef.
Diag(
Field->getLocation(), diag::note_uninit_reference_member);
720 ExprResult MemberInit = PerformEmptyInit(Loc, MemberEntity);
726 if (hadError || VerifyOnly) {
728 }
else if (Init < NumInits) {
730 }
else if (!isa<ImplicitValueInitExpr>(MemberInit.
get())) {
736 RequiresSecondPass =
true;
739 = dyn_cast<InitListExpr>(ILE->
getInit(Init))) {
740 FillInEmptyInitializations(MemberEntity, InnerILE,
741 RequiresSecondPass, ILE, Init, FillWithNoInit);
743 dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(Init))) {
744 FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
745 RequiresSecondPass, ILE, Init,
756 bool &RequiresSecondPass,
759 bool FillWithNoInit) {
761 "Should not have void type");
765 if (FillWithNoInit && VerifyOnly)
775 struct UpdateOuterILEWithUpdatedInit {
778 ~UpdateOuterILEWithUpdatedInit() {
782 } UpdateOuterRAII = {OuterILE, OuterIndex};
793 Entity, ILE, RequiresSecondPass, FillWithNoInit);
794 else if (RDecl->
isUnion() && isa<CXXRecordDecl>(RDecl) &&
795 cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
796 for (
auto *Field : RDecl->
fields()) {
797 if (
Field->hasInClassInitializer()) {
798 FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass,
807 unsigned NumElems = numStructUnionElements(ILE->
getType());
815 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {
816 for (
auto &
Base : CXXRD->bases()) {
820 FillInEmptyInitForBase(Init,
Base, Entity, ILE, RequiresSecondPass,
826 for (
auto *Field : RDecl->
fields()) {
827 if (
Field->isUnnamedBitfield())
833 FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass,
853 unsigned NumElements = NumInits;
855 ElementType = AType->getElementType();
856 if (
const auto *CAType = dyn_cast<ConstantArrayType>(AType))
857 NumElements = CAType->getSize().getZExtValue();
865 ElementType = VType->getElementType();
866 NumElements = VType->getNumElements();
872 bool SkipEmptyInitChecks =
false;
873 for (
unsigned Init = 0; Init != NumElements; ++Init) {
881 if (Init >= NumInits && (ILE->
hasArrayFiller() || SkipEmptyInitChecks))
884 Expr *InitExpr = (Init < NumInits ? ILE->
getInit(Init) :
nullptr);
885 if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
890 if (SkipEmptyInitChecks)
893 Expr *Filler =
nullptr;
899 PerformEmptyInit(ILE->
getEndLoc(), ElementEntity);
910 }
else if (VerifyOnly) {
911 SkipEmptyInitChecks =
true;
912 }
else if (Init < NumInits) {
927 if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {
933 RequiresSecondPass =
true;
937 = dyn_cast_or_null<InitListExpr>(InitExpr)) {
938 FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
939 ILE, Init, FillWithNoInit);
941 dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr)) {
942 FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
943 RequiresSecondPass, ILE, Init,
950 for (
const Stmt *Init : *IL)
951 if (Init && isa<DesignatedInitExpr>(Init))
958 bool TreatUnavailableAsInvalid,
959 bool InOverloadResolution)
960 : SemaRef(S), VerifyOnly(VerifyOnly),
961 TreatUnavailableAsInvalid(TreatUnavailableAsInvalid),
962 InOverloadResolution(InOverloadResolution) {
964 FullyStructuredList =
973 CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
976 if (!hadError && FullyStructuredList) {
977 bool RequiresSecondPass =
false;
978 FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass,
980 if (RequiresSecondPass && !hadError)
981 FillInEmptyInitializations(Entity, FullyStructuredList,
982 RequiresSecondPass,
nullptr, 0);
984 if (hadError && FullyStructuredList)
988int InitListChecker::numArrayElements(
QualType DeclType) {
990 int maxElements = 0x7FFFFFFF;
993 maxElements =
static_cast<int>(CAT->getSize().getZExtValue());
998int InitListChecker::numStructUnionElements(
QualType DeclType) {
1000 int InitializableMembers = 0;
1001 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl))
1002 InitializableMembers += CXXRD->getNumBases();
1003 for (
const auto *Field : structDecl->
fields())
1004 if (!
Field->isUnnamedBitfield())
1005 ++InitializableMembers;
1008 return std::min(InitializableMembers, 1);
1038 if (
CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(ParentRD)) {
1039 if (CXXRD->getNumBases()) {
1043 auto FieldIt = ParentRD->field_begin();
1044 assert(FieldIt != ParentRD->field_end() &&
1045 "no fields but have initializer for member?");
1046 return ++FieldIt == ParentRD->field_end();
1062 unsigned &StructuredIndex) {
1063 int maxElements = 0;
1066 maxElements = numArrayElements(T);
1068 maxElements = numStructUnionElements(T);
1072 llvm_unreachable(
"CheckImplicitInitList(): Illegal type");
1074 if (maxElements == 0) {
1077 diag::err_implicit_empty_initializer);
1084 InitListExpr *StructuredSubobjectInitList = getStructuredSubobjectInit(
1085 ParentIList, Index, T, StructuredList, StructuredIndex,
1088 unsigned StructuredSubobjectInitIndex = 0;
1091 unsigned StartIndex = Index;
1092 CheckListElementTypes(Entity, ParentIList, T,
1094 StructuredSubobjectInitList,
1095 StructuredSubobjectInitIndex);
1097 if (StructuredSubobjectInitList) {
1098 StructuredSubobjectInitList->
setType(T);
1100 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
1103 if (EndIndex < ParentIList->getNumInits() &&
1104 ParentIList->
getInit(EndIndex)) {
1115 diag::warn_missing_braces)
1121 StructuredSubobjectInitList->
getEndLoc()),
1127 if (!VerifyOnly && CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1129 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1145 unsigned DiagID = 0;
1156 DiagID = diag::warn_braces_around_init;
1163 DiagID = diag::warn_braces_around_init;
1189 llvm_unreachable(
"unexpected braced scalar init");
1208 bool TopLevelObject) {
1209 unsigned Index = 0, StructuredIndex = 0;
1210 CheckListElementTypes(Entity, IList, T,
true,
1211 Index, StructuredList, StructuredIndex, TopLevelObject);
1212 if (StructuredList) {
1218 StructuredList->
setType(ExprTy);
1226 bool ExtraInitsIsError = SemaRef.
getLangOpts().CPlusPlus ||
1228 hadError = ExtraInitsIsError;
1231 }
else if (StructuredIndex == 1 &&
1236 ? diag::err_excess_initializers_in_char_array_initializer
1237 : diag::ext_excess_initializers_in_char_array_initializer;
1241 unsigned DK = ExtraInitsIsError
1242 ? diag::err_excess_initializers_for_sizeless_type
1243 : diag::ext_excess_initializers_for_sizeless_type;
1253 unsigned DK = ExtraInitsIsError ? diag::err_excess_initializers
1254 : diag::ext_excess_initializers;
1262 !isa<InitListExpr>(IList->
getInit(0)))
1268 if (CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1271 bool HasEquivCtor =
false;
1277 if (!HasEquivCtor) {
1279 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1289 bool SubobjectIsDesignatorContext,
1292 unsigned &StructuredIndex,
1293 bool TopLevelObject) {
1297 CheckComplexType(Entity, IList, DeclType, Index,
1298 StructuredList, StructuredIndex);
1300 CheckScalarType(Entity, IList, DeclType, Index,
1301 StructuredList, StructuredIndex);
1303 CheckVectorType(Entity, IList, DeclType, Index,
1304 StructuredList, StructuredIndex);
1307 "non-aggregate records should be handed in CheckSubElementType");
1312 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1313 Bases = CXXRD->bases();
1314 CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->
field_begin(),
1315 SubobjectIsDesignatorContext, Index, StructuredList,
1316 StructuredIndex, TopLevelObject);
1321 CheckArrayType(Entity, IList, DeclType, Zero,
1322 SubobjectIsDesignatorContext, Index,
1323 StructuredList, StructuredIndex);
1328 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1332 CheckReferenceType(Entity, IList, DeclType, Index,
1333 StructuredList, StructuredIndex);
1336 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_init_objc_class) << DeclType;
1341 CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1345 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1356 unsigned &StructuredIndex,
1357 bool DirectlyDesignated) {
1361 return CheckReferenceType(Entity, IList, ElemType, Index,
1362 StructuredList, StructuredIndex);
1365 if (SubInitList->getNumInits() == 1 &&
1370 expr = SubInitList->getInit(0);
1373 }
else if (isa<ImplicitValueInitExpr>(
expr)) {
1377 "found implicit initialization for the wrong type");
1378 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1409 if (Seq || isa<InitListExpr>(
expr)) {
1412 if (Result.isInvalid())
1415 UpdateStructuredListElement(StructuredList, StructuredIndex,
1416 Result.getAs<
Expr>());
1419 }
else if (StructuredList) {
1420 UpdateStructuredListElement(StructuredList, StructuredIndex,
1430 return CheckScalarType(Entity, IList, ElemType, Index,
1431 StructuredList, StructuredIndex);
1443 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1472 UpdateStructuredListElement(StructuredList, StructuredIndex,
1490 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
1495 if (DirectlyDesignated && SemaRef.
getLangOpts().CPlusPlus && !hadError) {
1496 if (InOverloadResolution)
1500 diag::ext_designated_init_brace_elision)
1501 <<
expr->getSourceRange()
1517 "expected non-aggregate initialization to fail");
1529 unsigned &StructuredIndex) {
1530 assert(Index == 0 &&
"Index in explicit init list must be zero");
1540 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1545 if (!SemaRef.
getLangOpts().CPlusPlus && !VerifyOnly)
1554 for (
unsigned i = 0; i < 2; ++i) {
1556 CheckSubElementType(ElementEntity, IList, elementType, Index,
1557 StructuredList, StructuredIndex);
1565 unsigned &StructuredIndex) {
1571 ? diag::warn_cxx98_compat_empty_sizeless_initializer
1572 : diag::err_empty_sizeless_initializer)
1577 ? diag::warn_cxx98_compat_empty_scalar_initializer
1578 : diag::err_empty_scalar_initializer)
1592 SemaRef.
Diag(SubIList->getBeginLoc(), diag::ext_many_braces_around_init)
1595 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1598 }
else if (isa<DesignatedInitExpr>(
expr)) {
1601 diag::err_designator_for_scalar_or_sizeless_init)
1603 <<
expr->getSourceRange();
1613 Result = getDummyInit();
1622 Expr *ResultExpr =
nullptr;
1624 if (Result.isInvalid())
1627 ResultExpr = Result.getAs<
Expr>();
1629 if (ResultExpr !=
expr && !VerifyOnly) {
1632 IList->
setInit(Index, ResultExpr);
1635 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1643 unsigned &StructuredIndex) {
1651 diag::err_init_reference_member_uninitialized)
1673 Result = getDummyInit();
1682 if (Result.isInvalid())
1687 if (!VerifyOnly &&
expr)
1690 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1698 unsigned &StructuredIndex) {
1701 unsigned numEltsInit = 0;
1706 CheckEmptyInitializable(
1716 if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
1720 Result = getDummyInit();
1729 Expr *ResultExpr =
nullptr;
1730 if (Result.isInvalid())
1733 ResultExpr = Result.getAs<
Expr>();
1735 if (ResultExpr != Init && !VerifyOnly) {
1738 IList->
setInit(Index, ResultExpr);
1741 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1749 for (
unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1752 CheckEmptyInitializable(ElementEntity, IList->
getEndLoc());
1757 CheckSubElementType(ElementEntity, IList, elementType, Index,
1758 StructuredList, StructuredIndex);
1779 diag::warn_neon_vector_initializer_non_portable);
1781 const char *typeCode;
1791 llvm_unreachable(
"Invalid element type!");
1795 ? diag::note_neon_vector_initializer_non_portable_q
1796 : diag::note_neon_vector_initializer_non_portable)
1797 << typeCode << typeSize;
1807 for (
unsigned i = 0; i < maxElements; ++i) {
1816 CheckSubElementType(ElementEntity, IList, elementType, Index,
1817 StructuredList, StructuredIndex);
1829 CheckSubElementType(ElementEntity, IList, VecType, Index,
1830 StructuredList, StructuredIndex);
1831 numEltsInit += numIElts;
1836 if (numEltsInit != maxElements) {
1839 diag::err_vector_incorrect_num_initializers)
1840 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1863 SemaRef.
PDiag(diag::err_access_dtor_temp)
1871 llvm::APSInt elementIndex,
1872 bool SubobjectIsDesignatorContext,
1875 unsigned &StructuredIndex) {
1887 if (Index < IList->getNumInits()) {
1898 if (StructuredList) {
1899 UpdateStructuredListElement(StructuredList, StructuredIndex,
1912 SemaRef.
Diag(VAT->getSizeExpr()->getBeginLoc(),
1913 diag::err_variable_object_no_init)
1914 << VAT->getSizeExpr()->getSourceRange();
1922 llvm::APSInt maxElements(elementIndex.getBitWidth(),
1923 elementIndex.isUnsigned());
1924 bool maxElementsKnown =
false;
1926 maxElements = CAT->getSize();
1927 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
1928 elementIndex.setIsUnsigned(maxElements.isUnsigned());
1929 maxElementsKnown =
true;
1933 while (Index < IList->getNumInits()) {
1939 if (!SubobjectIsDesignatorContext)
1944 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1945 DeclType,
nullptr, &elementIndex, Index,
1946 StructuredList, StructuredIndex,
true,
1952 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
1953 maxElements = maxElements.extend(elementIndex.getBitWidth());
1954 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
1955 elementIndex = elementIndex.extend(maxElements.getBitWidth());
1956 elementIndex.setIsUnsigned(maxElements.isUnsigned());
1960 if (!maxElementsKnown && elementIndex > maxElements)
1961 maxElements = elementIndex;
1968 if (maxElementsKnown && elementIndex == maxElements)
1975 CheckSubElementType(ElementEntity, IList, elementType, Index,
1976 StructuredList, StructuredIndex);
1981 if (!maxElementsKnown && elementIndex > maxElements)
1982 maxElements = elementIndex;
1987 llvm::APSInt
Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
1991 SemaRef.
Diag(IList->
getBeginLoc(), diag::ext_typecheck_zero_array_size);
2002 if ((maxElementsKnown && elementIndex < maxElements) ||
2004 CheckEmptyInitializable(
2013 bool TopLevelObject) {
2015 unsigned FlexArrayDiag;
2016 if (isa<InitListExpr>(InitExpr) &&
2017 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
2019 FlexArrayDiag = diag::ext_flexible_array_init;
2020 }
else if (!TopLevelObject) {
2022 FlexArrayDiag = diag::err_flexible_array_init;
2025 FlexArrayDiag = diag::err_flexible_array_init;
2026 }
else if (cast<VarDecl>(Entity.
getDecl())->hasLocalStorage()) {
2028 FlexArrayDiag = diag::err_flexible_array_init;
2031 FlexArrayDiag = diag::ext_flexible_array_init;
2037 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2041 return FlexArrayDiag != diag::ext_flexible_array_init;
2044void InitListChecker::CheckStructUnionTypes(
2047 bool SubobjectIsDesignatorContext,
unsigned &Index,
2048 InitListExpr *StructuredList,
unsigned &StructuredIndex,
2049 bool TopLevelObject) {
2074 if (isa<CXXRecordDecl>(RD) &&
2075 cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
2076 if (!StructuredList)
2079 Field != FieldEnd; ++Field) {
2080 if (
Field->hasInClassInitializer()) {
2091 Field != FieldEnd; ++Field) {
2092 if (!
Field->isUnnamedBitfield()) {
2093 CheckEmptyInitializable(
2104 bool InitializedSomething =
false;
2107 for (
auto &
Base : Bases) {
2112 if (Init && isa<DesignatedInitExpr>(Init))
2119 CheckSubElementType(BaseEntity, IList,
Base.getType(), Index,
2120 StructuredList, StructuredIndex);
2121 InitializedSomething =
true;
2123 CheckEmptyInitializable(BaseEntity, InitLoc);
2139 size_t NumRecordDecls = llvm::count_if(RD->
decls(), [&](
const Decl *D) {
2140 return isa<FieldDecl>(D) || isa<RecordDecl>(D);
2142 bool CheckForMissingFields =
2144 bool HasDesignatedInit =
false;
2146 while (Index < IList->getNumInits()) {
2154 if (!SubobjectIsDesignatorContext)
2157 HasDesignatedInit =
true;
2161 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
2162 DeclType, &Field,
nullptr, Index,
2163 StructuredList, StructuredIndex,
2164 true, TopLevelObject))
2166 else if (!VerifyOnly) {
2169 while (std::next(F) != Field)
2178 InitializedSomething =
true;
2182 CheckForMissingFields =
false;
2199 if (NumRecordDecls == 1)
2201 if (
const auto *IL = dyn_cast<IntegerLiteral>(I))
2202 return IL->getValue().isZero();
2210 SemaRef.
Diag(InitLoc, diag::err_non_designated_init_used);
2215 if (Field == FieldEnd) {
2221 if (InitializedSomething && DeclType->
isUnionType())
2225 if (
Field->getType()->isIncompleteArrayType())
2228 if (
Field->isUnnamedBitfield()) {
2237 InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
2258 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2259 StructuredList, StructuredIndex);
2260 InitializedSomething =
true;
2271 if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
2272 Field != FieldEnd && !
Field->getType()->isIncompleteArrayType() &&
2278 if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) {
2280 diag::warn_missing_field_initializers) << *it;
2288 if (!StructuredList && Field != FieldEnd && !DeclType->
isUnionType() &&
2289 !
Field->getType()->isIncompleteArrayType()) {
2290 for (;
Field != FieldEnd && !hadError; ++
Field) {
2291 if (!
Field->isUnnamedBitfield() && !
Field->hasInClassInitializer())
2292 CheckEmptyInitializable(
2313 if (Field == FieldEnd || !
Field->getType()->isIncompleteArrayType() ||
2317 if (CheckFlexibleArrayInit(Entity, IList->
getInit(Index), *Field,
2327 if (isa<InitListExpr>(IList->
getInit(Index)))
2328 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2329 StructuredList, StructuredIndex);
2331 CheckImplicitInitList(MemberEntity, IList,
Field->getType(), Index,
2332 StructuredList, StructuredIndex);
2348 PE = IndirectField->
chain_end(); PI != PE; ++PI) {
2356 assert(isa<FieldDecl>(*PI));
2357 Replacements.back().setField(cast<FieldDecl>(*PI));
2364 &Replacements[0] + Replacements.size());
2371 for (
unsigned I = 0; I < NumIndexExprs; ++I)
2385 explicit FieldInitializerValidatorCCC(
RecordDecl *RD)
2393 std::unique_ptr<CorrectionCandidateCallback>
clone()
override {
2394 return std::make_unique<FieldInitializerValidatorCCC>(*
this);
2447 llvm::APSInt *NextElementIndex,
2450 unsigned &StructuredIndex,
2451 bool FinishSubobjectInit,
2452 bool TopLevelObject) {
2453 if (DesigIdx == DIE->
size()) {
2460 assert(isa<InitListExpr>(Init) &&
2461 "designator result in direct non-list initialization?");
2463 DIE->
getBeginLoc(), Init->getBeginLoc(), Init->getEndLoc());
2466 if (StructuredList) {
2469 : Seq.Perform(SemaRef, Entity,
Kind, Init);
2470 UpdateStructuredListElement(StructuredList, StructuredIndex,
2478 bool prevHadError = hadError;
2483 unsigned OldIndex = Index;
2486 CheckSubElementType(Entity, IList, CurrentObjectType, Index, StructuredList,
2487 StructuredIndex,
true);
2493 IList->
setInit(OldIndex, DIE);
2495 return hadError && !prevHadError;
2499 bool IsFirstDesignator = (DesigIdx == 0);
2500 if (IsFirstDesignator ? FullyStructuredList : StructuredList) {
2503 if (IsFirstDesignator)
2504 StructuredList = FullyStructuredList;
2506 Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2507 StructuredList->getInit(StructuredIndex) :
nullptr;
2508 if (!ExistingInit && StructuredList->hasArrayFiller())
2509 ExistingInit = StructuredList->getArrayFiller();
2512 StructuredList = getStructuredSubobjectInit(
2513 IList, Index, CurrentObjectType, StructuredList, StructuredIndex,
2515 else if (
InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2516 StructuredList = Result;
2529 diagnoseInitOverride(ExistingInit,
2535 dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2536 StructuredList = E->getUpdater();
2541 StructuredList->updateInit(SemaRef.
Context, StructuredIndex, DIUE);
2550 StructuredList =
nullptr;
2572 SemaRef.
Diag(Loc, diag::err_field_designator_non_aggr)
2573 << SemaRef.
getLangOpts().CPlusPlus << CurrentObjectType;
2583 if (
auto *FD = dyn_cast<FieldDecl>(ND)) {
2587 if (
auto *IFD = dyn_cast<IndirectFieldDecl>(ND)) {
2593 KnownField = cast<FieldDecl>(*IFD->chain_begin());
2604 if (!Lookup.empty()) {
2607 SemaRef.
Diag(Lookup.front()->getLocation(),
2608 diag::note_field_designator_found);
2615 FieldInitializerValidatorCCC CCC(RT->
getDecl());
2622 SemaRef.
PDiag(diag::err_field_designator_unknown_suggest)
2623 << FieldName << CurrentObjectType);
2624 KnownField = Corrected.getCorrectionDeclAs<
FieldDecl>();
2629 << FieldName << CurrentObjectType;
2636 unsigned NumBases = 0;
2637 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RT->
getDecl()))
2638 NumBases = CXXRD->getNumBases();
2640 unsigned FieldIndex = NumBases;
2643 if (FI->isUnnamedBitfield())
2659 if (StructuredList) {
2660 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2662 assert(StructuredList->getNumInits() == 1
2663 &&
"A union should never have more than one initializer!");
2665 Expr *ExistingInit = StructuredList->getInit(0);
2668 diagnoseInitOverride(
2673 StructuredList->resizeInits(SemaRef.
Context, 0);
2674 StructuredList->setInitializedFieldInUnion(
nullptr);
2677 StructuredList->setInitializedFieldInUnion(*Field);
2684 InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
2707 if (IsFirstDesignator && !VerifyOnly && SemaRef.
getLangOpts().CPlusPlus &&
2710 (*NextField)->getFieldIndex() >
Field->getFieldIndex() + 1)) {
2715 if (FI->isUnnamedBitfield())
2729 if (StructuredList && OldIndex <= StructuredList->getNumInits()) {
2730 if (
Expr *PrevInit = StructuredList->getInit(OldIndex)) {
2731 SemaRef.
Diag(PrevInit->getBeginLoc(),
2732 diag::note_previous_field_init)
2746 if (StructuredList && FieldIndex >= StructuredList->getNumInits())
2747 StructuredList->resizeInits(SemaRef.
Context, FieldIndex + 1);
2750 if (
Field->getType()->isIncompleteArrayType()) {
2752 if ((DesigIdx + 1) != DIE->
size()) {
2759 diag::err_designator_into_flexible_array_member)
2761 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2767 if (!hadError && !isa<InitListExpr>(DIE->
getInit()) &&
2768 !isa<StringLiteral>(DIE->
getInit())) {
2772 diag::err_flexible_array_init_needs_braces)
2774 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2781 if (!
Invalid && CheckFlexibleArrayInit(Entity, DIE->
getInit(), *Field,
2791 bool prevHadError = hadError;
2792 unsigned newStructuredIndex = FieldIndex;
2793 unsigned OldIndex = Index;
2798 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2799 StructuredList, newStructuredIndex);
2801 IList->
setInit(OldIndex, DIE);
2802 if (hadError && !prevHadError) {
2807 StructuredIndex = FieldIndex;
2813 unsigned newStructuredIndex = FieldIndex;
2817 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2818 FieldType,
nullptr,
nullptr, Index,
2819 StructuredList, newStructuredIndex,
2820 FinishSubobjectInit,
false))
2831 if (IsFirstDesignator) {
2834 StructuredIndex = FieldIndex;
2838 if (!FinishSubobjectInit)
2846 bool prevHadError = hadError;
2851 CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,
2852 false, Index, StructuredList, FieldIndex);
2853 return hadError && !prevHadError;
2875 << CurrentObjectType;
2880 Expr *IndexExpr =
nullptr;
2881 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2885 DesignatedEndIndex = DesignatedStartIndex;
2889 DesignatedStartIndex =
2891 DesignatedEndIndex =
2900 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
2905 if (isa<ConstantArrayType>(AT)) {
2906 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(),
false);
2907 DesignatedStartIndex
2908 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
2909 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
2911 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
2912 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2913 if (DesignatedEndIndex >= MaxElements) {
2916 diag::err_array_designator_too_large)
2923 unsigned DesignatedIndexBitWidth =
2925 DesignatedStartIndex =
2926 DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
2927 DesignatedEndIndex =
2928 DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
2929 DesignatedStartIndex.setIsUnsigned(
true);
2930 DesignatedEndIndex.setIsUnsigned(
true);
2933 bool IsStringLiteralInitUpdate =
2934 StructuredList && StructuredList->isStringLiteralInit();
2935 if (IsStringLiteralInitUpdate && VerifyOnly) {
2938 StructuredList =
nullptr;
2939 }
else if (IsStringLiteralInitUpdate) {
2952 unsigned PromotedCharTyWidth = Context.
getTypeSize(PromotedCharTy);
2957 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2958 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2959 StructuredList->resizeInits(Context, StrLen);
2963 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
2964 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2966 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
2967 if (CharTy != PromotedCharTy)
2971 StructuredList->updateInit(Context, i, Init);
2980 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2981 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2982 StructuredList->resizeInits(Context, StrLen);
2986 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
2987 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2989 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
2990 if (CharTy != PromotedCharTy)
2994 StructuredList->updateInit(Context, i, Init);
3001 if (StructuredList &&
3002 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
3003 StructuredList->resizeInits(SemaRef.
Context,
3004 DesignatedEndIndex.getZExtValue() + 1);
3010 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
3011 unsigned OldIndex = Index;
3016 while (DesignatedStartIndex <= DesignatedEndIndex) {
3022 if (CheckDesignatedInitializer(
3023 ElementEntity, IList, DIE, DesigIdx + 1, ElementType,
nullptr,
3024 nullptr, Index, StructuredList, ElementIndex,
3025 FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),
3030 ++DesignatedStartIndex;
3031 ElementIndex = DesignatedStartIndex.getZExtValue();
3036 if (IsFirstDesignator) {
3037 if (NextElementIndex)
3038 *NextElementIndex = DesignatedStartIndex;
3039 StructuredIndex = ElementIndex;
3043 if (!FinishSubobjectInit)
3047 bool prevHadError = hadError;
3048 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
3050 StructuredList, ElementIndex);
3051 return hadError && !prevHadError;
3057InitListChecker::getStructuredSubobjectInit(
InitListExpr *IList,
unsigned Index,
3060 unsigned StructuredIndex,
3062 bool IsFullyOverwritten) {
3063 if (!StructuredList)
3066 Expr *ExistingInit =
nullptr;
3067 if (StructuredIndex < StructuredList->getNumInits())
3068 ExistingInit = StructuredList->
getInit(StructuredIndex);
3070 if (
InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
3079 if (!IsFullyOverwritten)
3102 diagnoseInitOverride(ExistingInit, InitRange);
3105 unsigned ExpectedNumInits = 0;
3106 if (Index < IList->getNumInits()) {
3107 if (
auto *Init = dyn_cast_or_null<InitListExpr>(IList->
getInit(Index)))
3108 ExpectedNumInits = Init->getNumInits();
3114 createInitListExpr(CurrentObjectType, InitRange, ExpectedNumInits);
3123InitListChecker::createInitListExpr(
QualType CurrentObjectType,
3125 unsigned ExpectedNumInits) {
3129 QualType ResultType = CurrentObjectType;
3132 Result->setType(ResultType);
3135 unsigned NumElements = 0;
3140 NumElements = CAType->getSize().getZExtValue();
3143 if (NumElements > ExpectedNumInits)
3147 NumElements = VType->getNumElements();
3149 NumElements = numStructUnionElements(CurrentObjectType);
3152 Result->reserveInits(SemaRef.
Context, NumElements);
3159void InitListChecker::UpdateStructuredListElement(
InitListExpr *StructuredList,
3160 unsigned &StructuredIndex,
3163 if (!StructuredList)
3167 StructuredIndex,
expr)) {
3173 diagnoseInitOverride(PrevInit,
expr->getSourceRange());
3184 InitListChecker Check(*
this, Entity, From,
Type,
true,
3187 return !Check.HadError();
3208 return S.
Diag(Loc, diag::err_array_designator_negative)
3211 Value.setIsUnsigned(
true);
3236 llvm::APSInt IndexValue;
3237 if (!Index->isTypeDependent() && !Index->isValueDependent())
3242 Designators.push_back(ASTDesignator(InitExpressions.size(),
3245 InitExpressions.push_back(Index);
3253 llvm::APSInt StartValue;
3254 llvm::APSInt EndValue;
3259 if (!StartDependent)
3265 if (!StartIndex || !EndIndex)
3269 if (StartDependent || EndDependent) {
3271 }
else if (StartValue.getBitWidth() > EndValue.getBitWidth())
3272 EndValue = EndValue.extend(StartValue.getBitWidth());
3273 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
3274 StartValue = StartValue.extend(EndValue.getBitWidth());
3276 if (!StartDependent && !EndDependent && EndValue < StartValue) {
3282 Designators.push_back(ASTDesignator(InitExpressions.size(),
3286 InitExpressions.push_back(StartIndex);
3287 InitExpressions.push_back(EndIndex);
3295 if (
Invalid || Init.isInvalid())
3302 EqualOrColonLoc, GNUSyntax,
3303 Init.getAs<
Expr>());
3310InitializedEntity::InitializedEntity(
ASTContext &Context,
unsigned Index,
3315 Kind = EK_ArrayElement;
3318 Kind = EK_VectorElement;
3322 assert(CT &&
"Unexpected type");
3323 Kind = EK_ComplexElement;
3331 bool IsInheritedVirtualBase,
3336 Result.Base = {
Base, IsInheritedVirtualBase};
3353 return Variable.VariableOrMember->getDeclName();
3375 llvm_unreachable(
"Invalid EntityKind!");
3408 llvm_unreachable(
"Invalid EntityKind!");
3442unsigned InitializedEntity::dumpImpl(raw_ostream &
OS)
const {
3445 for (
unsigned I = 0; I != Depth; ++I)
3470 OS <<
"Block (lambda)";
3473 OS <<
"LambdaCapture ";
3480 D->printQualifiedName(
OS);
3489 dumpImpl(llvm::errs());
3544 for (
const Step &S : llvm::reverse(Steps)) {
3603 llvm_unreachable(
"Invalid EntityKind!");
3611InitializationSequence
3612::AddAddressOverloadResolutionStep(
FunctionDecl *Function,
3614 bool HadMultipleCandidates) {
3617 S.Type = Function->getType();
3618 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3619 S.Function.Function = Function;
3620 S.Function.FoundDecl = Found;
3639 bool BindingTemporary) {
3664 bool HadMultipleCandidates) {
3668 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3669 S.Function.Function = Function;
3670 S.Function.FoundDecl = FoundDecl;
3709 bool TopLevelOfInitList) {
3727 bool HadMultipleCandidates,
bool FromInitList,
bool AsInitList) {
3733 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3734 S.Function.Function = Constructor;
3735 S.Function.FoundDecl = FoundDecl;
3778 Steps.insert(Steps.begin(), S);
3839 "Can only rewrap trivial init lists.");
3843 Steps.insert(Steps.begin(), S);
3847 S.WrappingSyntacticList = Syntactic;
3854 this->Failure = Failure;
3855 this->FailedOverloadResult =
Result;
3876 if (!Init.empty()) {
3896 "consuming an object of unretainable type?");
3917 bool TreatUnavailableAsInvalid);
3928 bool TreatUnavailableAsInvalid) {
3942 List->getNumInits()),
3947 List->getExprLoc(), List->getBeginLoc(), List->getEndLoc());
3949 TreatUnavailableAsInvalid);
3979 bool CopyInitializing,
bool AllowExplicit,
3980 bool OnlyListConstructors,
bool IsListInit,
3981 bool SecondStepOfCopyInit =
false) {
3987 if (!Info.Constructor || Info.Constructor->isInvalidDecl())
4004 bool SuppressUserConversions =
4005 SecondStepOfCopyInit ||
4006 (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
4009 if (Info.ConstructorTmpl)
4011 Info.ConstructorTmpl, Info.FoundDecl,
4012 nullptr, Args, CandidateSet, SuppressUserConversions,
4013 false, AllowExplicit);
4022 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
4026 CandidateSet, SuppressUserConversions,
4027 false, AllowExplicit,
4043 if (S.
getLangOpts().CPlusPlus17 && Args.size() == 1 &&
4044 !SecondStepOfCopyInit) {
4046 auto *SourceRD =
Initializer->getType()->getAsCXXRecordDecl();
4048 const auto &Conversions = SourceRD->getVisibleConversionFunctions();
4049 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4059 Conv = cast<CXXConversionDecl>(D);
4063 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4064 CandidateSet, AllowExplicit, AllowExplicit,
4068 DestType, CandidateSet, AllowExplicit,
4095 bool IsListInit =
false,
4096 bool IsInitListCopy =
false) {
4097 assert(((!IsListInit && !IsInitListCopy) ||
4098 (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
4099 "IsListInit/IsInitListCopy must come with a single initializer list "
4102 (IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) :
nullptr;
4126 UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isPRValue() &&
4136 assert(DestRecordType &&
"Constructor initialization requires record type");
4138 = cast<CXXRecordDecl>(DestRecordType->
getDecl());
4146 bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
4156 bool AsInitializerList =
false;
4168 AsInitializerList =
true;
4174 CandidateSet, DestType, Ctors, Best,
4175 CopyInitialization, AllowExplicit,
4186 AsInitializerList =
false;
4188 CandidateSet, DestType, Ctors, Best,
4189 CopyInitialization, AllowExplicit,
4203 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4207 if (
auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
4209 QualType ConvType = CD->getConversionType();
4211 "should not have selected this conversion function");
4213 HadMultipleCandidates);
4244 if (IsListInit && !Kind.AllowExplicit() && CtorDecl->
isExplicit()) {
4264 Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,
4265 IsListInit | IsInitListCopy, AsInitializerList);
4278 bool HadMultipleCandidates =
false;
4281 UnqualifiedTargetType,
4283 &HadMultipleCandidates)) {
4285 HadMultipleCandidates);
4286 SourceType = Fn->getType();
4318 bool TreatUnavailableAsInvalid) {
4358 T1Quals, cv2T2, T2, T2Quals, Sequence);
4388 TreatUnavailableAsInvalid);
4409 bool TreatUnavailableAsInvalid) {
4421 TreatUnavailableAsInvalid);
4447 Expr *InitListAsExpr = InitList;
4457 if (!isa<VariableArrayType>(DestAT) &&
4467 TreatUnavailableAsInvalid);
4500 TreatUnavailableAsInvalid))
4504 Expr *InitListAsExpr = InitList;
4506 DestType, Sequence,
true);
4524 ET && ET->getDecl()->isFixed() &&
4573 if (Init->getType()->isRecordType() ||
4574 (Init->getType()->isNullPtrType() && DestType->
isBooleanType())) {
4581 Expr *SubInit[1] = { Init };
4584 TreatUnavailableAsInvalid);
4591 InitListChecker CheckInitList(S, Entity, InitList,
4592 DestType,
true, TreatUnavailableAsInvalid);
4593 if (CheckInitList.HadError()) {
4615 "Must have incompatible references when binding via conversion");
4626 bool AllowExplicitCtors =
false;
4627 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
4638 if (!Info.Constructor)
4641 if (!Info.Constructor->isInvalidDecl() &&
4642 Info.Constructor->isConvertingConstructor(
true)) {
4643 if (Info.ConstructorTmpl)
4645 Info.ConstructorTmpl, Info.FoundDecl,
4648 false, AllowExplicitCtors);
4651 Info.Constructor, Info.FoundDecl,
Initializer, CandidateSet,
4653 false, AllowExplicitCtors);
4668 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4671 if (isa<UsingShadowDecl>(D))
4672 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4679 Conv = cast<CXXConversionDecl>(D);
4687 if ((AllowRValues ||
4691 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4693 false, AllowExplicitConvs);
4696 Conv, I.getPair(), ActingDC,
Initializer, DestType, CandidateSet,
4697 false, AllowExplicitConvs);
4715 Function->setReferenced();
4719 if (isa<CXXConversionDecl>(Function))
4720 cv3T3 = Function->getReturnType();
4732 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4734 HadMultipleCandidates);
4744 assert(!isa<CXXConstructorDecl>(Function) &&
4745 "should not have conversion after constructor");
4749 ICS.
Standard = Best->FinalConversion;
4770 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
4772 else if (RefConv & Sema::ReferenceConversions::ObjC)
4774 else if (RefConv & Sema::ReferenceConversions::Function)
4776 else if (RefConv & Sema::ReferenceConversions::Qualification) {
4811 T1Quals, cv2T2, T2, T2Quals, Sequence);
4858 if (isLValueRef || T1Function) {
4861 (Kind.isCStyleOrFunctionalCast() &&
4865 if (RefConv & (Sema::ReferenceConversions::DerivedToBase |
4866 Sema::ReferenceConversions::ObjC)) {
4869 if (RefConv & (Sema::ReferenceConversions::Qualification))
4873 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
4877 }
else if (RefConv & Sema::ReferenceConversions::Qualification) {
4881 }
else if (RefConv & Sema::ReferenceConversions::Function) {
4901 (isLValueRef || InitCategory.
isRValue())) {
4906 isLValueRef, Sequence);
4940 switch (RefRelationship) {
4952 llvm_unreachable(
"unexpected kind of compatible initializer");
4976 (Kind.isCStyleOrFunctionalCast() &&
5005 auto T1QualsIgnoreAS = T1Quals;
5006 auto T2QualsIgnoreAS = T2Quals;
5009 T2QualsIgnoreAS.removeAddressSpace();
5012 if (T1QualsIgnoreAS != T2QualsIgnoreAS)
5022 cv1T4 = cv1T4WithAS;
5027 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
5029 else if (RefConv & Sema::ReferenceConversions::ObjC)
5031 else if (RefConv & Sema::ReferenceConversions::Qualification) {
5048 isLValueRef, Sequence);
5057 if (RefRelationship ==