33#include "llvm/ADT/APInt.h"
34#include "llvm/ADT/FoldingSet.h"
35#include "llvm/ADT/PointerIntPair.h"
36#include "llvm/ADT/STLForwardCompat.h"
37#include "llvm/ADT/SmallString.h"
38#include "llvm/ADT/SmallVector.h"
39#include "llvm/ADT/StringExtras.h"
40#include "llvm/Support/ErrorHandling.h"
41#include "llvm/Support/raw_ostream.h"
77 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
95 auto IsCharOrUnsignedChar = [](
const QualType &
T) {
96 const BuiltinType *BT = dyn_cast<BuiltinType>(
T.getTypePtr());
101 case StringLiteralKind::UTF8:
111 case StringLiteralKind::Ordinary:
115 return (SL->
getKind() == StringLiteralKind::UTF8 &&
129 case StringLiteralKind::UTF16:
137 case StringLiteralKind::UTF32:
145 case StringLiteralKind::Wide:
153 case StringLiteralKind::Unevaluated:
154 assert(
false &&
"Unevaluated string literal in initialization");
158 llvm_unreachable(
"missed a StringLiteral kind?");
179 if (isa<StringLiteral>(
E) || isa<ObjCEncodeExpr>(
E))
190 if (isa<CompoundLiteralExpr>(
E))
205 if (
const auto *VD = dyn_cast_if_present<VarDecl>(
D); VD && VD->isConstexpr())
215 Sema &S,
bool CheckC23ConstexprInit =
false) {
217 auto *ConstantArrayTy =
219 uint64_t StrLength = ConstantArrayTy->getZExtSize();
221 if (CheckC23ConstexprInit)
228 llvm::APInt ConstVal(32, StrLength);
254 diag::err_initializer_string_for_char_array_too_long)
260 diag::ext_initializer_string_for_char_array_too_long)
308class InitListChecker {
310 bool hadError =
false;
312 bool TreatUnavailableAsInvalid;
313 bool InOverloadResolution;
318 unsigned CurEmbedIndex = 0;
329 unsigned &StructuredIndex);
333 bool TopLevelObject =
false);
336 bool SubobjectIsDesignatorContext,
339 unsigned &StructuredIndex,
340 bool TopLevelObject =
false);
345 unsigned &StructuredIndex,
346 bool DirectlyDesignated =
false);
351 unsigned &StructuredIndex);
356 unsigned &StructuredIndex);
361 unsigned &StructuredIndex);
365 unsigned &StructuredIndex);
370 bool SubobjectIsDesignatorContext,
unsigned &Index,
372 unsigned &StructuredIndex,
373 bool TopLevelObject =
false);
376 llvm::APSInt elementIndex,
377 bool SubobjectIsDesignatorContext,
unsigned &Index,
379 unsigned &StructuredIndex);
385 llvm::APSInt *NextElementIndex,
388 unsigned &StructuredIndex,
389 bool FinishSubobjectInit,
390 bool TopLevelObject);
394 unsigned StructuredIndex,
396 bool IsFullyOverwritten =
false);
397 void UpdateStructuredListElement(
InitListExpr *StructuredList,
398 unsigned &StructuredIndex,
402 unsigned ExpectedNumInits);
403 int numArrayElements(
QualType DeclType);
404 int numStructUnionElements(
QualType DeclType);
412 bool UnionOverride =
false,
413 bool FullyOverwritten =
true) {
418 ? (UnionOverride ? diag::ext_initializer_union_overrides
419 : diag::ext_initializer_overrides)
420 : diag::warn_initializer_overrides;
422 if (InOverloadResolution && SemaRef.
getLangOpts().CPlusPlus) {
443 DiagID = diag::err_initializer_overrides_destructed;
463 << NewInitRange << FullyOverwritten << OldInit->
getType();
492 bool FillWithNoInit);
493 void FillInEmptyInitForField(
unsigned Init,
FieldDecl *Field,
496 bool FillWithNoInit =
false);
500 bool FillWithNoInit =
false);
503 bool TopLevelObject);
508 Expr *Result =
nullptr;
520 assert(AType &&
"expected array type when initializing array");
522 if (
const auto *CAType = dyn_cast<ConstantArrayType>(AType))
523 ElsCount = std::min(CAType->getSize().getZExtValue(),
524 ElsCount - CurEmbedIndex);
534 CurEmbedIndex, ElsCount);
535 CurEmbedIndex += ElsCount;
546 bool VerifyOnly,
bool TreatUnavailableAsInvalid,
547 bool InOverloadResolution =
false,
552 : InitListChecker(S, Entity, IL,
T,
true,
555 &AggrDeductionCandidateParamTypes) {}
557 bool HadError() {
return hadError; }
561 InitListExpr *getFullyStructuredList()
const {
return FullyStructuredList; }
578 bool EmptyInitList = SemaRef.
getLangOpts().CPlusPlus11 &&
591 InitExpr = VerifyOnly
609 if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
613 InitSeq.getFailedCandidateSet()
614 .BestViableFunction(SemaRef,
Kind.getLocation(), Best);
616 assert(O ==
OR_Success &&
"Inconsistent overload resolution");
623 bool IsInStd =
false;
625 ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
630 if (IsInStd && llvm::StringSwitch<bool>(R->
getName())
631 .Cases(
"basic_string",
"deque",
"forward_list",
true)
632 .Cases(
"list",
"map",
"multimap",
"multiset",
true)
633 .Cases(
"priority_queue",
"queue",
"set",
"stack",
true)
634 .Cases(
"unordered_map",
"unordered_set",
"vector",
true)
636 InitSeq.InitializeFrom(
640 TreatUnavailableAsInvalid);
645 diag::warn_invalid_initializer_from_system_header);
648 diag::note_used_in_initialization_here);
650 SemaRef.
Diag(
Loc, diag::note_used_in_initialization_here);
657 InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
660 diag::note_in_omitted_aggregate_initializer)
663 bool IsTrailingArrayNewMember =
666 SemaRef.
Diag(
Loc, diag::note_in_omitted_aggregate_initializer)
667 << (IsTrailingArrayNewMember ? 2 : 0)
676 : InitSeq.Perform(SemaRef, Entity,
Kind, SubInit);
684 if (FullyStructuredList)
686 PerformEmptyInit(
Loc, Entity);
689void InitListChecker::FillInEmptyInitForBase(
692 bool &RequiresSecondPass,
bool FillWithNoInit) {
699 : PerformEmptyInit(ILE->
getEndLoc(), BaseEntity);
706 assert(Init < ILE->getNumInits() &&
"should have been expanded");
711 FillInEmptyInitializations(BaseEntity, InnerILE, RequiresSecondPass,
712 ILE,
Init, FillWithNoInit);
714 dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(
Init))) {
715 FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),
716 RequiresSecondPass, ILE,
Init,
721void InitListChecker::FillInEmptyInitForField(
unsigned Init,
FieldDecl *Field,
724 bool &RequiresSecondPass,
725 bool FillWithNoInit) {
733 if (!RType->getDecl()->isUnion())
734 assert((
Init < NumInits || VerifyOnly) &&
735 "This ILE should have been expanded");
737 if (FillWithNoInit) {
738 assert(!VerifyOnly &&
"should not fill with no-init in verify-only mode");
750 if (
Field->hasInClassInitializer()) {
764 RequiresSecondPass =
true;
769 if (
Field->getType()->isReferenceType()) {
775 SemaRef.
Diag(
Loc, diag::err_init_reference_member_uninitialized)
779 SemaRef.
Diag(
Field->getLocation(), diag::note_uninit_reference_member);
791 if (hadError || VerifyOnly) {
793 }
else if (
Init < NumInits) {
795 }
else if (!isa<ImplicitValueInitExpr>(MemberInit.
get())) {
801 RequiresSecondPass =
true;
805 FillInEmptyInitializations(MemberEntity, InnerILE,
806 RequiresSecondPass, ILE,
Init, FillWithNoInit);
808 dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(
Init))) {
809 FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
810 RequiresSecondPass, ILE,
Init,
821 bool &RequiresSecondPass,
824 bool FillWithNoInit) {
826 "Should not have void type");
830 if (FillWithNoInit && VerifyOnly)
840 struct UpdateOuterILEWithUpdatedInit {
843 ~UpdateOuterILEWithUpdatedInit() {
847 } UpdateOuterRAII = {OuterILE, OuterIndex};
858 RequiresSecondPass, FillWithNoInit);
860 assert((!RDecl->
isUnion() || !isa<CXXRecordDecl>(RDecl) ||
861 !cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) &&
862 "We should have computed initialized fields already");
866 unsigned NumElems = numStructUnionElements(ILE->
getType());
874 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {
875 for (
auto &
Base : CXXRD->bases()) {
879 FillInEmptyInitForBase(
Init,
Base, Entity, ILE, RequiresSecondPass,
885 for (
auto *Field : RDecl->
fields()) {
886 if (
Field->isUnnamedBitField())
892 FillInEmptyInitForField(
Init, Field, Entity, ILE, RequiresSecondPass,
914 ElementType = AType->getElementType();
915 if (
const auto *CAType = dyn_cast<ConstantArrayType>(AType))
916 NumElements = CAType->getZExtSize();
924 ElementType = VType->getElementType();
925 NumElements = VType->getNumElements();
931 bool SkipEmptyInitChecks =
false;
944 if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
949 if (SkipEmptyInitChecks)
952 Expr *Filler =
nullptr;
958 PerformEmptyInit(ILE->
getEndLoc(), ElementEntity);
969 }
else if (VerifyOnly) {
970 SkipEmptyInitChecks =
true;
971 }
else if (
Init < NumInits) {
986 if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {
992 RequiresSecondPass =
true;
996 = dyn_cast_or_null<InitListExpr>(InitExpr)) {
997 FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
998 ILE,
Init, FillWithNoInit);
1000 dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr)) {
1001 FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
1002 RequiresSecondPass, ILE,
Init,
1010 if (isa_and_nonnull<DesignatedInitExpr>(
Init))
1015InitListChecker::InitListChecker(
1017 bool VerifyOnly,
bool TreatUnavailableAsInvalid,
bool InOverloadResolution,
1019 : SemaRef(S), VerifyOnly(VerifyOnly),
1020 TreatUnavailableAsInvalid(TreatUnavailableAsInvalid),
1021 InOverloadResolution(InOverloadResolution),
1022 AggrDeductionCandidateParamTypes(AggrDeductionCandidateParamTypes) {
1024 FullyStructuredList =
1033 CheckExplicitInitList(Entity, IL,
T, FullyStructuredList,
1036 if (!hadError && !AggrDeductionCandidateParamTypes && FullyStructuredList) {
1037 bool RequiresSecondPass =
false;
1038 FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass,
1040 if (RequiresSecondPass && !hadError)
1041 FillInEmptyInitializations(Entity, FullyStructuredList,
1042 RequiresSecondPass,
nullptr, 0);
1044 if (hadError && FullyStructuredList)
1048int InitListChecker::numArrayElements(
QualType DeclType) {
1050 int maxElements = 0x7FFFFFFF;
1053 maxElements =
static_cast<int>(CAT->getZExtSize());
1058int InitListChecker::numStructUnionElements(
QualType DeclType) {
1060 int InitializableMembers = 0;
1061 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl))
1062 InitializableMembers += CXXRD->getNumBases();
1063 for (
const auto *Field : structDecl->
fields())
1064 if (!
Field->isUnnamedBitField())
1065 ++InitializableMembers;
1068 return std::min(InitializableMembers, 1);
1074 return RT->getDecl();
1076 return Inject->getDecl();
1106 if (
CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(ParentRD)) {
1107 if (CXXRD->getNumBases()) {
1111 auto FieldIt = ParentRD->field_begin();
1112 assert(FieldIt != ParentRD->field_end() &&
1113 "no fields but have initializer for member?");
1114 return ++FieldIt == ParentRD->field_end();
1130 unsigned &StructuredIndex) {
1131 int maxElements = 0;
1134 maxElements = numArrayElements(
T);
1136 maxElements = numStructUnionElements(
T);
1140 llvm_unreachable(
"CheckImplicitInitList(): Illegal type");
1142 if (maxElements == 0) {
1145 diag::err_implicit_empty_initializer);
1152 InitListExpr *StructuredSubobjectInitList = getStructuredSubobjectInit(
1153 ParentIList, Index,
T, StructuredList, StructuredIndex,
1156 unsigned StructuredSubobjectInitIndex = 0;
1159 unsigned StartIndex = Index;
1160 CheckListElementTypes(Entity, ParentIList,
T,
1162 StructuredSubobjectInitList,
1163 StructuredSubobjectInitIndex);
1165 if (StructuredSubobjectInitList) {
1166 StructuredSubobjectInitList->
setType(
T);
1168 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
1171 if (EndIndex < ParentIList->getNumInits() &&
1172 ParentIList->
getInit(EndIndex)) {
1183 diag::warn_missing_braces)
1189 StructuredSubobjectInitList->
getEndLoc()),
1195 if (!VerifyOnly && CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1197 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1213 unsigned DiagID = 0;
1225 DiagID = diag::warn_braces_around_init;
1232 DiagID = diag::warn_braces_around_init;
1258 llvm_unreachable(
"unexpected braced scalar init");
1277 bool TopLevelObject) {
1278 unsigned Index = 0, StructuredIndex = 0;
1279 CheckListElementTypes(Entity, IList,
T,
true,
1280 Index, StructuredList, StructuredIndex, TopLevelObject);
1281 if (StructuredList) {
1287 StructuredList->
setType(ExprTy);
1295 bool ExtraInitsIsError = SemaRef.
getLangOpts().CPlusPlus ||
1297 hadError = ExtraInitsIsError;
1300 }
else if (StructuredIndex == 1 &&
1305 ? diag::err_excess_initializers_in_char_array_initializer
1306 : diag::ext_excess_initializers_in_char_array_initializer;
1310 unsigned DK = ExtraInitsIsError
1311 ? diag::err_excess_initializers_for_sizeless_type
1312 : diag::ext_excess_initializers_for_sizeless_type;
1322 unsigned DK = ExtraInitsIsError ? diag::err_excess_initializers
1323 : diag::ext_excess_initializers;
1331 !isa<InitListExpr>(IList->
getInit(0)))
1337 if (CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1340 bool HasEquivCtor =
false;
1346 if (!HasEquivCtor) {
1348 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1358 bool SubobjectIsDesignatorContext,
1361 unsigned &StructuredIndex,
1362 bool TopLevelObject) {
1366 CheckComplexType(Entity, IList, DeclType, Index,
1367 StructuredList, StructuredIndex);
1369 CheckScalarType(Entity, IList, DeclType, Index,
1370 StructuredList, StructuredIndex);
1372 CheckVectorType(Entity, IList, DeclType, Index,
1373 StructuredList, StructuredIndex);
1374 }
else if (
const RecordDecl *RD = getRecordDecl(DeclType)) {
1380 "non-aggregate records should be handed in CheckSubElementType");
1381 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1382 Bases = CXXRD->bases();
1384 Bases = cast<CXXRecordDecl>(RD)->bases();
1386 CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(),
1387 SubobjectIsDesignatorContext, Index, StructuredList,
1388 StructuredIndex, TopLevelObject);
1393 CheckArrayType(Entity, IList, DeclType, Zero,
1394 SubobjectIsDesignatorContext, Index,
1395 StructuredList, StructuredIndex);
1400 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1404 CheckReferenceType(Entity, IList, DeclType, Index,
1405 StructuredList, StructuredIndex);
1408 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_init_objc_class) << DeclType;
1413 CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1420 assert(AggrDeductionCandidateParamTypes);
1421 AggrDeductionCandidateParamTypes->push_back(DeclType);
1424 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1435 unsigned &StructuredIndex,
1436 bool DirectlyDesignated) {
1440 return CheckReferenceType(Entity, IList, ElemType, Index,
1441 StructuredList, StructuredIndex);
1444 if (SubInitList->getNumInits() == 1 &&
1449 expr = SubInitList->getInit(0);
1452 }
else if (isa<ImplicitValueInitExpr>(
expr)) {
1456 "found implicit initialization for the wrong type");
1457 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1479 if (TmpEntity.getType()->isDependentType()) {
1484 assert(AggrDeductionCandidateParamTypes);
1498 if (isa<InitListExpr, DesignatedInitExpr>(
expr) ||
1499 !isa_and_present<ConstantArrayType>(
1502 AggrDeductionCandidateParamTypes->push_back(ElemType);
1514 if (
Seq || isa<InitListExpr>(
expr)) {
1515 if (
auto *Embed = dyn_cast<EmbedExpr>(
expr)) {
1516 expr = HandleEmbed(Embed, Entity);
1520 if (Result.isInvalid())
1523 UpdateStructuredListElement(StructuredList, StructuredIndex,
1524 Result.getAs<
Expr>());
1527 }
else if (StructuredList) {
1528 UpdateStructuredListElement(StructuredList, StructuredIndex,
1533 if (AggrDeductionCandidateParamTypes)
1534 AggrDeductionCandidateParamTypes->push_back(ElemType);
1542 return CheckScalarType(Entity, IList, ElemType, Index,
1543 StructuredList, StructuredIndex);
1557 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1586 UpdateStructuredListElement(StructuredList, StructuredIndex,
1604 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
1609 if (DirectlyDesignated && SemaRef.
getLangOpts().CPlusPlus && !hadError) {
1610 if (InOverloadResolution)
1614 diag::ext_designated_init_brace_elision)
1615 <<
expr->getSourceRange()
1630 assert(
Copy.isInvalid() &&
1631 "expected non-aggregate initialization to fail");
1643 unsigned &StructuredIndex) {
1644 assert(Index == 0 &&
"Index in explicit init list must be zero");
1654 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1659 if (!SemaRef.
getLangOpts().CPlusPlus && !VerifyOnly)
1668 for (
unsigned i = 0; i < 2; ++i) {
1670 CheckSubElementType(ElementEntity, IList, elementType, Index,
1671 StructuredList, StructuredIndex);
1679 unsigned &StructuredIndex) {
1686 ? diag::warn_cxx98_compat_empty_sizeless_initializer
1687 : diag::err_empty_sizeless_initializer)
1692 ? diag::warn_cxx98_compat_empty_scalar_initializer
1693 : diag::err_empty_scalar_initializer)
1709 SemaRef.
Diag(SubIList->getBeginLoc(), diag::ext_many_braces_around_init)
1712 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1715 }
else if (isa<DesignatedInitExpr>(
expr)) {
1718 diag::err_designator_for_scalar_or_sizeless_init)
1720 <<
expr->getSourceRange();
1725 }
else if (
auto *Embed = dyn_cast<EmbedExpr>(
expr)) {
1726 expr = HandleEmbed(Embed, Entity);
1732 Result = getDummyInit();
1741 Expr *ResultExpr =
nullptr;
1743 if (Result.isInvalid())
1746 ResultExpr = Result.getAs<
Expr>();
1748 if (ResultExpr !=
expr && !VerifyOnly && !CurEmbed) {
1751 IList->
setInit(Index, ResultExpr);
1755 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1758 if (AggrDeductionCandidateParamTypes)
1759 AggrDeductionCandidateParamTypes->push_back(DeclType);
1766 unsigned &StructuredIndex) {
1774 diag::err_init_reference_member_uninitialized)
1796 Result = getDummyInit();
1805 if (Result.isInvalid())
1810 if (!VerifyOnly &&
expr)
1813 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1815 if (AggrDeductionCandidateParamTypes)
1816 AggrDeductionCandidateParamTypes->push_back(DeclType);
1823 unsigned &StructuredIndex) {
1826 unsigned numEltsInit = 0;
1831 CheckEmptyInitializable(
1841 if (!isa<InitListExpr>(
Init) &&
Init->getType()->isVectorType()) {
1845 Result = getDummyInit();
1854 Expr *ResultExpr =
nullptr;
1855 if (Result.isInvalid())
1858 ResultExpr = Result.getAs<
Expr>();
1860 if (ResultExpr !=
Init && !VerifyOnly) {
1863 IList->
setInit(Index, ResultExpr);
1866 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1868 if (AggrDeductionCandidateParamTypes)
1869 AggrDeductionCandidateParamTypes->push_back(elementType);
1876 for (
unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1879 CheckEmptyInitializable(ElementEntity, IList->
getEndLoc());
1884 CheckSubElementType(ElementEntity, IList, elementType, Index,
1885 StructuredList, StructuredIndex);
1893 if (isBigEndian && (
T->getVectorKind() == VectorKind::Neon ||
1894 T->getVectorKind() == VectorKind::NeonPoly)) {
1906 diag::warn_neon_vector_initializer_non_portable);
1908 const char *typeCode;
1918 llvm_unreachable(
"Invalid element type!");
1922 ? diag::note_neon_vector_initializer_non_portable_q
1923 : diag::note_neon_vector_initializer_non_portable)
1924 << typeCode << typeSize;
1934 for (
unsigned i = 0; i < maxElements; ++i) {
1943 CheckSubElementType(ElementEntity, IList, elementType, Index,
1944 StructuredList, StructuredIndex);
1956 CheckSubElementType(ElementEntity, IList, VecType, Index,
1957 StructuredList, StructuredIndex);
1958 numEltsInit += numIElts;
1963 if (numEltsInit != maxElements) {
1966 diag::err_vector_incorrect_num_initializers)
1967 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1990 SemaRef.
PDiag(diag::err_access_dtor_temp)
2004 InitType =
Parent->getType();
2010 ExprList.size() == 1
2011 ? dyn_cast_if_present<EmbedExpr>(ExprList[0]->IgnoreParens())
2020 const bool TypesMatch =
2031 llvm::APSInt elementIndex,
2032 bool SubobjectIsDesignatorContext,
2035 unsigned &StructuredIndex) {
2053 if (Index < IList->getNumInits()) {
2066 if (StructuredList) {
2067 UpdateStructuredListElement(StructuredList, StructuredIndex,
2072 if (AggrDeductionCandidateParamTypes)
2073 AggrDeductionCandidateParamTypes->push_back(DeclType);
2094 SemaRef.
Diag(VAT->getSizeExpr()->getBeginLoc(),
2095 diag::err_variable_object_no_init)
2096 << VAT->getSizeExpr()->getSourceRange();
2105 llvm::APSInt maxElements(elementIndex.getBitWidth(),
2106 elementIndex.isUnsigned());
2107 bool maxElementsKnown =
false;
2109 maxElements = CAT->getSize();
2110 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
2111 elementIndex.setIsUnsigned(maxElements.isUnsigned());
2112 maxElementsKnown =
true;
2116 while (Index < IList->getNumInits()) {
2122 if (!SubobjectIsDesignatorContext)
2127 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
2128 DeclType,
nullptr, &elementIndex, Index,
2129 StructuredList, StructuredIndex,
true,
2135 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
2136 maxElements = maxElements.extend(elementIndex.getBitWidth());
2137 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
2138 elementIndex = elementIndex.extend(maxElements.getBitWidth());
2139 elementIndex.setIsUnsigned(maxElements.isUnsigned());
2143 if (!maxElementsKnown && elementIndex > maxElements)
2144 maxElements = elementIndex;
2151 if (maxElementsKnown && elementIndex == maxElements)
2155 SemaRef.
Context, StructuredIndex, Entity);
2157 unsigned EmbedElementIndexBeforeInit = CurEmbedIndex;
2159 CheckSubElementType(ElementEntity, IList, elementType, Index,
2160 StructuredList, StructuredIndex);
2165 elementIndex + CurEmbedIndex - EmbedElementIndexBeforeInit - 1;
2167 auto Embed = cast<EmbedExpr>(
Init);
2169 EmbedElementIndexBeforeInit - 1;
2175 if (!maxElementsKnown && elementIndex > maxElements)
2176 maxElements = elementIndex;
2181 llvm::APSInt
Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
2185 SemaRef.
Diag(IList->
getBeginLoc(), diag::ext_typecheck_zero_array_size);
2189 elementType, maxElements,
nullptr, ArraySizeModifier::Normal, 0);
2196 if ((maxElementsKnown && elementIndex < maxElements) ||
2198 CheckEmptyInitializable(
2207 bool TopLevelObject) {
2209 unsigned FlexArrayDiag;
2210 if (isa<InitListExpr>(InitExpr) &&
2211 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
2213 FlexArrayDiag = diag::ext_flexible_array_init;
2214 }
else if (!TopLevelObject) {
2216 FlexArrayDiag = diag::err_flexible_array_init;
2219 FlexArrayDiag = diag::err_flexible_array_init;
2220 }
else if (cast<VarDecl>(Entity.
getDecl())->hasLocalStorage()) {
2222 FlexArrayDiag = diag::err_flexible_array_init;
2225 FlexArrayDiag = diag::ext_flexible_array_init;
2231 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2235 return FlexArrayDiag != diag::ext_flexible_array_init;
2238void InitListChecker::CheckStructUnionTypes(
2241 bool SubobjectIsDesignatorContext,
unsigned &Index,
2242 InitListExpr *StructuredList,
unsigned &StructuredIndex,
2243 bool TopLevelObject) {
2244 const RecordDecl *RD = getRecordDecl(DeclType);
2266 if (isa<CXXRecordDecl>(RD) &&
2267 cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
2268 if (!StructuredList)
2271 Field != FieldEnd; ++Field) {
2272 if (
Field->hasInClassInitializer() ||
2273 (
Field->isAnonymousStructOrUnion() &&
2274 Field->getType()->getAsCXXRecordDecl()->hasInClassInitializer())) {
2280 llvm_unreachable(
"Couldn't find in-class initializer");
2286 Field != FieldEnd; ++Field) {
2287 if (!
Field->isUnnamedBitField()) {
2288 CheckEmptyInitializable(
2299 bool InitializedSomething =
false;
2302 for (
auto I = Bases.begin(),
E = Bases.end(); I !=
E; ++I) {
2308 if (isa_and_nonnull<DesignatedInitExpr>(
Init))
2325 if (AggrDeductionCandidateParamTypes &&
Base.isPackExpansion()) {
2326 AggrDeductionCandidateParamTypes->push_back(
2331 if (Index < IList->getNumInits())
2343 CheckSubElementType(BaseEntity, IList,
Base.getType(), Index,
2344 StructuredList, StructuredIndex);
2345 InitializedSomething =
true;
2347 CheckEmptyInitializable(BaseEntity, InitLoc);
2362 size_t NumRecordDecls = llvm::count_if(RD->
decls(), [&](
const Decl *
D) {
2363 return isa<FieldDecl>(D) || isa<RecordDecl>(D);
2365 bool HasDesignatedInit =
false;
2369 while (Index < IList->getNumInits()) {
2377 if (!SubobjectIsDesignatorContext)
2380 HasDesignatedInit =
true;
2384 bool DesignatedInitFailed = CheckDesignatedInitializer(
2385 Entity, IList, DIE, 0, DeclType, &Field,
nullptr, Index,
2386 StructuredList, StructuredIndex,
true, TopLevelObject);
2387 if (DesignatedInitFailed)
2392 if (!VerifyOnly &&
D->isFieldDesignator()) {
2394 InitializedFields.insert(F);
2395 if (!DesignatedInitFailed) {
2404 InitializedSomething =
true;
2421 if (NumRecordDecls == 1)
2423 if (
const auto *IL = dyn_cast<IntegerLiteral>(I))
2424 return IL->getValue().isZero();
2432 SemaRef.
Diag(InitLoc, diag::err_non_designated_init_used);
2437 if (Field == FieldEnd) {
2443 if (InitializedSomething && RD->
isUnion())
2447 if (
Field->getType()->isIncompleteArrayType())
2450 if (
Field->isUnnamedBitField()) {
2459 InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
2480 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2481 StructuredList, StructuredIndex);
2482 InitializedSomething =
true;
2483 InitializedFields.insert(*Field);
2485 if (RD->
isUnion() && StructuredList) {
2496 bool IsCDesignatedInitializer =
2497 HasDesignatedInit && !SemaRef.
getLangOpts().CPlusPlus;
2498 if (!VerifyOnly && InitializedSomething && !RD->
isUnion() &&
2500 !IsCDesignatedInitializer) {
2507 if (HasDesignatedInit && InitializedFields.count(*it))
2510 if (!it->isUnnamedBitField() && !it->hasInClassInitializer() &&
2511 !it->getType()->isIncompleteArrayType()) {
2512 auto Diag = HasDesignatedInit
2513 ? diag::warn_missing_designated_field_initializers
2514 : diag::warn_missing_field_initializers;
2523 if (!StructuredList && Field != FieldEnd && !RD->
isUnion() &&
2524 !
Field->getType()->isIncompleteArrayType()) {
2525 for (;
Field != FieldEnd && !hadError; ++
Field) {
2526 if (!
Field->isUnnamedBitField() && !
Field->hasInClassInitializer())
2527 CheckEmptyInitializable(
2548 if (Field == FieldEnd || !
Field->getType()->isIncompleteArrayType() ||
2552 if (CheckFlexibleArrayInit(Entity, IList->
getInit(Index), *Field,
2562 if (isa<InitListExpr>(IList->
getInit(Index)) ||
2563 AggrDeductionCandidateParamTypes)
2564 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2565 StructuredList, StructuredIndex);
2567 CheckImplicitInitList(MemberEntity, IList,
Field->getType(), Index,
2568 StructuredList, StructuredIndex);
2570 if (RD->
isUnion() && StructuredList) {
2589 PE = IndirectField->
chain_end(); PI != PE; ++PI) {
2597 assert(isa<FieldDecl>(*PI));
2598 Replacements.back().setFieldDecl(cast<FieldDecl>(*PI));
2605 &Replacements[0] + Replacements.size());
2612 for (
unsigned I = 0; I < NumIndexExprs; ++I)
2626 explicit FieldInitializerValidatorCCC(
const RecordDecl *RD)
2634 std::unique_ptr<CorrectionCandidateCallback>
clone()
override {
2635 return std::make_unique<FieldInitializerValidatorCCC>(*
this);
2688 llvm::APSInt *NextElementIndex,
2691 unsigned &StructuredIndex,
2692 bool FinishSubobjectInit,
2693 bool TopLevelObject) {
2694 if (DesigIdx == DIE->
size()) {
2701 assert(isa<InitListExpr>(
Init) &&
2702 "designator result in direct non-list initialization?");
2707 if (StructuredList) {
2711 UpdateStructuredListElement(StructuredList, StructuredIndex,
2715 if (AggrDeductionCandidateParamTypes)
2716 AggrDeductionCandidateParamTypes->push_back(CurrentObjectType);
2721 bool prevHadError = hadError;
2726 unsigned OldIndex = Index;
2729 CheckSubElementType(Entity, IList, CurrentObjectType, Index, StructuredList,
2730 StructuredIndex,
true);
2736 IList->
setInit(OldIndex, DIE);
2738 return hadError && !prevHadError;
2742 bool IsFirstDesignator = (DesigIdx == 0);
2743 if (IsFirstDesignator ? FullyStructuredList : StructuredList) {
2746 if (IsFirstDesignator)
2747 StructuredList = FullyStructuredList;
2749 Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2750 StructuredList->getInit(StructuredIndex) :
nullptr;
2751 if (!ExistingInit && StructuredList->hasArrayFiller())
2752 ExistingInit = StructuredList->getArrayFiller();
2755 StructuredList = getStructuredSubobjectInit(
2756 IList, Index, CurrentObjectType, StructuredList, StructuredIndex,
2758 else if (
InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2759 StructuredList = Result;
2772 diagnoseInitOverride(ExistingInit,
2779 dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2780 StructuredList =
E->getUpdater();
2785 StructuredList->updateInit(SemaRef.
Context, StructuredIndex, DIUE);
2794 StructuredList =
nullptr;
2800 if (
D->isFieldDesignator()) {
2810 RecordDecl *RD = getRecordDecl(CurrentObjectType);
2814 Loc =
D->getFieldLoc();
2816 SemaRef.
Diag(
Loc, diag::err_field_designator_non_aggr)
2817 << SemaRef.
getLangOpts().CPlusPlus << CurrentObjectType;
2826 if (
auto *FD = dyn_cast_if_present<FieldDecl>(VD)) {
2828 }
else if (
auto *IFD = dyn_cast_if_present<IndirectFieldDecl>(VD)) {
2834 KnownField = cast<FieldDecl>(*IFD->chain_begin());
2851 SemaRef.
Diag(
D->getFieldLoc(), diag::err_field_designator_nonfield)
2853 SemaRef.
Diag(Lookup.front()->getLocation(),
2854 diag::note_field_designator_found);
2861 FieldInitializerValidatorCCC CCC(RD);
2868 SemaRef.
PDiag(diag::err_field_designator_unknown_suggest)
2869 << FieldName << CurrentObjectType);
2870 KnownField = Corrected.getCorrectionDeclAs<
FieldDecl>();
2881 SemaRef.
Diag(
Loc, diag::err_field_designator_unknown)
2889 unsigned NumBases = 0;
2890 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2891 NumBases = CXXRD->getNumBases();
2893 unsigned FieldIndex = NumBases;
2895 for (
auto *FI : RD->
fields()) {
2896 if (FI->isUnnamedBitField())
2912 if (StructuredList) {
2913 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2915 assert(StructuredList->getNumInits() == 1
2916 &&
"A union should never have more than one initializer!");
2918 Expr *ExistingInit = StructuredList->getInit(0);
2921 diagnoseInitOverride(
2929 StructuredList->resizeInits(SemaRef.
Context, 0);
2930 StructuredList->setInitializedFieldInUnion(
nullptr);
2933 StructuredList->setInitializedFieldInUnion(*Field);
2940 InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
2963 if (IsFirstDesignator && !VerifyOnly && SemaRef.
getLangOpts().CPlusPlus &&
2966 (*NextField)->getFieldIndex() >
Field->getFieldIndex() + 1)) {
2970 if (FI->isUnnamedBitField())
2981 diag::ext_designated_init_reordered)
2984 unsigned OldIndex = StructuredIndex - 1;
2985 if (StructuredList && OldIndex <= StructuredList->getNumInits()) {
2986 if (
Expr *PrevInit = StructuredList->getInit(OldIndex)) {
2987 SemaRef.
Diag(PrevInit->getBeginLoc(),
2988 diag::note_previous_field_init)
2998 D->setFieldDecl(*Field);
3002 if (StructuredList && FieldIndex >= StructuredList->getNumInits())
3003 StructuredList->resizeInits(SemaRef.
Context, FieldIndex + 1);
3006 if (
Field->getType()->isIncompleteArrayType()) {
3008 if ((DesigIdx + 1) != DIE->
size()) {
3015 diag::err_designator_into_flexible_array_member)
3017 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
3023 if (!hadError && !isa<InitListExpr>(DIE->
getInit()) &&
3024 !isa<StringLiteral>(DIE->
getInit())) {
3028 diag::err_flexible_array_init_needs_braces)
3030 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
3037 if (!
Invalid && CheckFlexibleArrayInit(Entity, DIE->
getInit(), *Field,
3047 bool prevHadError = hadError;
3048 unsigned newStructuredIndex = FieldIndex;
3049 unsigned OldIndex = Index;
3054 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
3055 StructuredList, newStructuredIndex);
3057 IList->
setInit(OldIndex, DIE);
3058 if (hadError && !prevHadError) {
3063 StructuredIndex = FieldIndex;
3069 unsigned newStructuredIndex = FieldIndex;
3073 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
3074 FieldType,
nullptr,
nullptr, Index,
3075 StructuredList, newStructuredIndex,
3076 FinishSubobjectInit,
false))
3087 if (IsFirstDesignator) {
3094 StructuredIndex = FieldIndex;
3098 if (!FinishSubobjectInit)
3106 bool prevHadError = hadError;
3111 CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,
3112 false, Index, StructuredList, FieldIndex);
3113 return hadError && !prevHadError;
3134 SemaRef.
Diag(
D->getLBracketLoc(), diag::err_array_designator_non_array)
3135 << CurrentObjectType;
3140 Expr *IndexExpr =
nullptr;
3141 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
3142 if (
D->isArrayDesignator()) {
3145 DesignatedEndIndex = DesignatedStartIndex;
3147 assert(
D->isArrayRangeDesignator() &&
"Need array-range designator");
3149 DesignatedStartIndex =
3151 DesignatedEndIndex =
3160 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
3165 if (isa<ConstantArrayType>(AT)) {
3166 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(),
false);
3167 DesignatedStartIndex
3168 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
3169 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
3171 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
3172 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
3173 if (DesignatedEndIndex >= MaxElements) {
3176 diag::err_array_designator_too_large)
3183 unsigned DesignatedIndexBitWidth =
3185 DesignatedStartIndex =
3186 DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
3187 DesignatedEndIndex =
3188 DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
3189 DesignatedStartIndex.setIsUnsigned(
true);
3190 DesignatedEndIndex.setIsUnsigned(
true);
3193 bool IsStringLiteralInitUpdate =
3194 StructuredList && StructuredList->isStringLiteralInit();
3195 if (IsStringLiteralInitUpdate && VerifyOnly) {
3198 StructuredList =
nullptr;
3199 }
else if (IsStringLiteralInitUpdate) {
3212 unsigned PromotedCharTyWidth = Context.
getTypeSize(PromotedCharTy);
3217 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
3218 StrLen = cast<ConstantArrayType>(AT)->getZExtSize();
3219 StructuredList->resizeInits(Context, StrLen);
3223 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
3224 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
3226 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
3227 if (CharTy != PromotedCharTy)
3231 StructuredList->updateInit(Context, i,
Init);
3240 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
3241 StrLen = cast<ConstantArrayType>(AT)->getZExtSize();
3242 StructuredList->resizeInits(Context, StrLen);
3246 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
3247 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
3249 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
3250 if (CharTy != PromotedCharTy)
3254 StructuredList->updateInit(Context, i,
Init);
3261 if (StructuredList &&
3262 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
3263 StructuredList->resizeInits(SemaRef.
Context,
3264 DesignatedEndIndex.getZExtValue() + 1);
3270 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
3271 unsigned OldIndex = Index;
3276 while (DesignatedStartIndex <= DesignatedEndIndex) {
3282 if (CheckDesignatedInitializer(
3283 ElementEntity, IList, DIE, DesigIdx + 1, ElementType,
nullptr,
3284 nullptr, Index, StructuredList, ElementIndex,
3285 FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),
3290 ++DesignatedStartIndex;
3291 ElementIndex = DesignatedStartIndex.getZExtValue();
3296 if (IsFirstDesignator) {
3297 if (NextElementIndex)
3298 *NextElementIndex = DesignatedStartIndex;
3299 StructuredIndex = ElementIndex;
3303 if (!FinishSubobjectInit)
3307 bool prevHadError = hadError;
3308 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
3310 StructuredList, ElementIndex);
3311 return hadError && !prevHadError;
3317InitListChecker::getStructuredSubobjectInit(
InitListExpr *IList,
unsigned Index,
3320 unsigned StructuredIndex,
3322 bool IsFullyOverwritten) {
3323 if (!StructuredList)
3326 Expr *ExistingInit =
nullptr;
3327 if (StructuredIndex < StructuredList->getNumInits())
3328 ExistingInit = StructuredList->
getInit(StructuredIndex);
3330 if (
InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
3339 if (!IsFullyOverwritten)
3362 diagnoseInitOverride(ExistingInit, InitRange);
3365 unsigned ExpectedNumInits = 0;
3366 if (Index < IList->getNumInits()) {
3367 if (
auto *
Init = dyn_cast_or_null<InitListExpr>(IList->
getInit(Index)))
3368 ExpectedNumInits =
Init->getNumInits();
3374 createInitListExpr(CurrentObjectType, InitRange, ExpectedNumInits);
3383InitListChecker::createInitListExpr(
QualType CurrentObjectType,
3385 unsigned ExpectedNumInits) {
3389 QualType ResultType = CurrentObjectType;
3392 Result->setType(ResultType);
3395 unsigned NumElements = 0;
3400 NumElements = CAType->getZExtSize();
3403 if (NumElements > ExpectedNumInits)
3407 NumElements = VType->getNumElements();
3409 NumElements = numStructUnionElements(CurrentObjectType);
3414 Result->reserveInits(SemaRef.
Context, NumElements);
3421void InitListChecker::UpdateStructuredListElement(
InitListExpr *StructuredList,
3422 unsigned &StructuredIndex,
3425 if (!StructuredList)
3429 StructuredIndex,
expr)) {
3435 diagnoseInitOverride(PrevInit,
expr->getSourceRange());
3444 InitListChecker Check(*
this, Entity, From,
Type,
true,
3447 return !Check.HadError();
3468 return S.
Diag(
Loc, diag::err_array_designator_negative)
3471 Value.setIsUnsigned(
true);
3489 if (
D.isFieldDesignator()) {
3490 Designators.push_back(ASTDesignator::CreateFieldDesignator(
3491 D.getFieldDecl(),
D.getDotLoc(),
D.getFieldLoc()));
3492 }
else if (
D.isArrayDesignator()) {
3493 Expr *Index =
static_cast<Expr *
>(
D.getArrayIndex());
3494 llvm::APSInt IndexValue;
3495 if (!Index->isTypeDependent() && !Index->isValueDependent())
3500 Designators.push_back(ASTDesignator::CreateArrayDesignator(
3501 InitExpressions.size(),
D.getLBracketLoc(),
D.getRBracketLoc()));
3502 InitExpressions.push_back(Index);
3504 }
else if (
D.isArrayRangeDesignator()) {
3505 Expr *StartIndex =
static_cast<Expr *
>(
D.getArrayRangeStart());
3506 Expr *EndIndex =
static_cast<Expr *
>(
D.getArrayRangeEnd());
3507 llvm::APSInt StartValue;
3508 llvm::APSInt EndValue;
3513 if (!StartDependent)
3519 if (!StartIndex || !EndIndex)
3523 if (StartDependent || EndDependent) {
3525 }
else if (StartValue.getBitWidth() > EndValue.getBitWidth())
3526 EndValue = EndValue.extend(StartValue.getBitWidth());
3527 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
3528 StartValue = StartValue.extend(EndValue.getBitWidth());
3530 if (!StartDependent && !EndDependent && EndValue < StartValue) {
3531 Diag(
D.getEllipsisLoc(), diag::err_array_designator_empty_range)
3536 Designators.push_back(ASTDesignator::CreateArrayRangeDesignator(
3537 InitExpressions.size(),
D.getLBracketLoc(),
D.getEllipsisLoc(),
3538 D.getRBracketLoc()));
3539 InitExpressions.push_back(StartIndex);
3540 InitExpressions.push_back(EndIndex);
3550 EqualOrColonLoc, GNUSyntax,
3558InitializedEntity::InitializedEntity(
ASTContext &Context,
unsigned Index,
3563 Kind = EK_ArrayElement;
3566 Kind = EK_VectorElement;
3570 assert(CT &&
"Unexpected type");
3571 Kind = EK_ComplexElement;
3579 bool IsInheritedVirtualBase,
3584 Result.Base = {
Base, IsInheritedVirtualBase};
3602 return Variable.VariableOrMember->getDeclName();
3624 llvm_unreachable(
"Invalid EntityKind!");
3658 llvm_unreachable(
"Invalid EntityKind!");
3693unsigned InitializedEntity::dumpImpl(raw_ostream &OS)
const {
3696 for (
unsigned I = 0; I != Depth; ++I)
3713 case EK_New: OS <<
"New";
break;
3717 case EK_Base: OS <<
"Base";
break;
3724 OS <<
"Block (lambda)";
3727 OS <<
"LambdaCapture ";
3734 D->printQualifiedName(OS);
3737 OS <<
" '" <<
getType() <<
"'\n";
3743 dumpImpl(llvm::errs());
3798 for (
const Step &S : llvm::reverse(Steps)) {
3858 llvm_unreachable(
"Invalid EntityKind!");
3866InitializationSequence
3869 bool HadMultipleCandidates) {
3873 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3875 S.Function.FoundDecl =
Found;
3894 bool BindingTemporary) {
3919 bool HadMultipleCandidates) {
3923 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3925 S.Function.FoundDecl = FoundDecl;
3964 bool TopLevelOfInitList) {
3982 bool HadMultipleCandidates,
bool FromInitList,
bool AsInitList) {
3988 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3989 S.Function.Function = Constructor;
3990 S.Function.FoundDecl = FoundDecl;
4033 Steps.insert(Steps.begin(), S);
4094 "Can only rewrap trivial init lists.");
4098 Steps.insert(Steps.begin(), S);
4102 S.WrappingSyntacticList = Syntactic;
4109 this->Failure = Failure;
4110 this->FailedOverloadResult =
Result;
4131 if (!
Init.empty()) {
4151 "consuming an object of unretainable type?");
4172 bool TreatUnavailableAsInvalid);
4183 bool TreatUnavailableAsInvalid) {
4197 List->getNumInits()),
4202 List->getExprLoc(), List->getBeginLoc(), List->getEndLoc());
4204 TreatUnavailableAsInvalid);
4231 bool CopyInitializing,
bool AllowExplicit,
bool OnlyListConstructors,
4232 bool IsListInit,
bool RequireActualConstructor,
4233 bool SecondStepOfCopyInit =
false) {
4239 if (!Info.Constructor || Info.Constructor->isInvalidDecl())
4256 bool SuppressUserConversions =
4257 SecondStepOfCopyInit ||
4258 (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
4261 if (Info.ConstructorTmpl)
4263 Info.ConstructorTmpl, Info.FoundDecl,
4264 nullptr, Args, CandidateSet, SuppressUserConversions,
4265 false, AllowExplicit);
4274 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
4278 CandidateSet, SuppressUserConversions,
4279 false, AllowExplicit,
4295 if (S.
getLangOpts().CPlusPlus17 && Args.size() == 1 &&
4296 !RequireActualConstructor && !SecondStepOfCopyInit) {
4298 auto *SourceRD =
Initializer->getType()->getAsCXXRecordDecl();
4300 const auto &Conversions = SourceRD->getVisibleConversionFunctions();
4301 for (
auto I = Conversions.begin(),
E = Conversions.end(); I !=
E; ++I) {
4304 D =
D->getUnderlyingDecl();
4311 Conv = cast<CXXConversionDecl>(
D);
4315 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4316 CandidateSet, AllowExplicit, AllowExplicit,
4320 DestType, CandidateSet, AllowExplicit,
4347 bool IsListInit =
false,
4348 bool IsInitListCopy =
false) {
4349 assert(((!IsListInit && !IsInitListCopy) ||
4350 (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
4351 "IsListInit/IsInitListCopy must come with a single initializer list "
4354 (IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) :
nullptr;
4364 bool RequireActualConstructor =
4379 if (S.
getLangOpts().CPlusPlus17 && !RequireActualConstructor &&
4380 UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isPRValue() &&
4390 assert(DestRecordType &&
"Constructor initialization requires record type");
4392 = cast<CXXRecordDecl>(DestRecordType->
getDecl());
4400 bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
4410 bool AsInitializerList =
false;
4422 AsInitializerList =
true;
4428 S, Kind.getLocation(), Args, CandidateSet, DestType, Ctors, Best,
4429 CopyInitialization, AllowExplicit,
4430 true, IsListInit, RequireActualConstructor);
4439 AsInitializerList =
false;
4441 S, Kind.getLocation(), UnwrappedArgs, CandidateSet, DestType, Ctors,
4442 Best, CopyInitialization, AllowExplicit,
4443 false, IsListInit, RequireActualConstructor);
4455 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4459 if (
auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
4461 QualType ConvType = CD->getConversionType();
4463 "should not have selected this conversion function");
4465 HadMultipleCandidates);
4496 if (IsListInit && !Kind.AllowExplicit() && CtorDecl->
isExplicit()) {
4516 Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,
4517 IsListInit | IsInitListCopy, AsInitializerList);
4530 bool HadMultipleCandidates =
false;
4533 UnqualifiedTargetType,
4535 &HadMultipleCandidates)) {
4537 HadMultipleCandidates);
4538 SourceType = Fn->getType();
4557 bool TopLevelOfInitList);
4571 bool TreatUnavailableAsInvalid) {
4611 T1Quals, cv2T2, T2, T2Quals, Sequence,
4642 TreatUnavailableAsInvalid);
4674 bool TreatUnavailableAsInvalid) {
4686 TreatUnavailableAsInvalid);
4724 !IsDesignatedInit) {
4729 Expr *InitListAsExpr = InitList;
4739 if (!isa<VariableArrayType>(DestAT) &&
4749 TreatUnavailableAsInvalid);
4782 TreatUnavailableAsInvalid))
4786 Expr *InitListAsExpr = InitList;
4788 DestType, Sequence,
true);
4806 ET && ET->getDecl()->isFixed() &&
4855 if (
Init->getType()->isRecordType() ||
4866 TreatUnavailableAsInvalid);
4873 InitListChecker CheckInitList(S, Entity, InitList,
4874 DestType,
true, TreatUnavailableAsInvalid);
4875 if (CheckInitList.HadError()) {
4897 "Must have incompatible references when binding via conversion");
4908 bool AllowExplicitCtors =
false;
4909 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
4920 if (!Info.Constructor)
4923 if (!Info.Constructor->isInvalidDecl() &&
4924 Info.Constructor->isConvertingConstructor(
true)) {
4925 if (Info.ConstructorTmpl)
4927 Info.ConstructorTmpl, Info.FoundDecl,
4930 false, AllowExplicitCtors);
4933 Info.Constructor, Info.FoundDecl,
Initializer, CandidateSet,
4935 false, AllowExplicitCtors);
4950 for (
auto I = Conversions.begin(),
E = Conversions.end(); I !=
E; ++I) {
4953 if (isa<UsingShadowDecl>(
D))
4954 D = cast<UsingShadowDecl>(
D)->getTargetDecl();
4961 Conv = cast<CXXConversionDecl>(
D);
4969 if ((AllowRValues ||
4973 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4975 false, AllowExplicitConvs);
4978 Conv, I.getPair(), ActingDC,
Initializer, DestType, CandidateSet,
4979 false, AllowExplicitConvs);
5001 if (isa<CXXConversionDecl>(
Function))
5014 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
5016 HadMultipleCandidates);
5026 assert(!isa<CXXConstructorDecl>(
Function) &&
5027 "should not have conversion after constructor");
5031 ICS.
Standard = Best->FinalConversion;
5052 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
5054 else if (RefConv & Sema::ReferenceConversions::ObjC)
5056 else if (RefConv & Sema::ReferenceConversions::Function)
5058 else if (RefConv & Sema::ReferenceConversions::Qualification) {
5075 bool TopLevelOfInitList) {
5093 T1Quals, cv2T2, T2, T2Quals, Sequence,
5094 TopLevelOfInitList);
5118 bool TopLevelOfInitList) {
5142 if (isLValueRef || T1Function) {
5145 (Kind.isCStyleOrFunctionalCast() &&
5149 if (RefConv & (Sema::ReferenceConversions::DerivedToBase |
5150 Sema::ReferenceConversions::ObjC)) {
5153 if (RefConv & (Sema::ReferenceConversions::Qualification))
5157 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
5161 }
else if (RefConv & Sema::ReferenceConversions::Qualification) {
5165 }
else if (RefConv & Sema::ReferenceConversions::Function) {
5185 (isLValueRef || InitCategory.
isRValue())) {
5190 isLValueRef, Sequence);
5224 switch (RefRelationship) {
5236 llvm_unreachable(
"unexpected kind of compatible initializer");
5260 (Kind.isCStyleOrFunctionalCast() &&
5289 auto T1QualsIgnoreAS = T1Quals;
5290 auto T2QualsIgnoreAS = T2Quals;
5293 T2QualsIgnoreAS.removeAddressSpace();
5296 if (T1QualsIgnoreAS != T2QualsIgnoreAS)
5306 cv1T4 = cv1T4WithAS;
5311 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
5313 else if (RefConv & Sema::ReferenceConversions::ObjC)
5315 else if (RefConv & Sema::ReferenceConversions::Qualification) {
5332 isLValueRef, Sequence);
5372 Sema::AllowedExplicit::None,
5374 Kind.isCStyleOrFunctionalCast(),
5393 TopLevelOfInitList);
5402 ((T1CVRQuals | T2CVRQuals) != T1CVRQuals ||
5447 assert((!InitList || InitList->
getNumInits() == 0) &&
5448 "Shouldn't use value-init for non-empty init lists");
5459 if (
CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
5460 bool NeedZeroInitialization =
true;
5475 NeedZeroInitialization =
false;
5483 if (NeedZeroInitialization)
5497 ClassDecl->hasUninitializedReferenceMember()) {
5505 Expr *InitListAsExpr = InitList;
5507 bool InitListSyntax = InitList;
5512 S, Entity, Kind, Args,
T, Entity.
getType(), Sequence, InitListSyntax);
5562 unsigned EntityIndexToProcess = 0;
5565 Expr *ArrayFiller =
nullptr;
5566 FieldDecl *InitializedFieldInUnion =
nullptr;
5570 Expr *Arg,
Expr **InitExpr =
nullptr) {
5572 S, SubEntity, SubKind, Arg ?
MultiExprArg(Arg) : std::nullopt);
5586 ER = IS.
Perform(S, SubEntity, SubKind,
5593 *InitExpr = ER.
get();
5595 InitExprs.push_back(ER.
get());
5603 uint64_t ArrayLength;
5611 ArrayLength = CAT->getZExtSize();
5612 ResultType = Entity.
getType();
5619 const Expr *SE = VAT->getSizeExpr();
5625 ArrayLength = Args.size();
5627 EntityIndexToProcess = ArrayLength;
5631 for (
Expr *
E : Args) {
5636 if (!HandleInitializedEntity(SubEntity, SubKind,
E))
5644 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
true);
5645 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr, &ArrayFiller))
5649 if (ResultType.
isNull()) {
5656 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
5670 if (EntityIndexToProcess < Args.size()) {
5676 Expr *
E = Args[EntityIndexToProcess];
5679 if (!HandleInitializedEntity(SubEntity, SubKind,
E))
5687 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
5689 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr))
5692 EntityIndexToProcess++;
5705 if (EntityIndexToProcess < Args.size()) {
5707 Expr *
E = Args[EntityIndexToProcess];
5725 if (!HandleInitializedEntity(SubEntity, SubKind,
E))
5733 InitializedFieldInUnion = FD;
5734 EntityIndexToProcess = 1;
5746 Kind.getParenOrBraceRange().getEnd(), FD);
5750 InitExprs.push_back(DIE.
get());
5760 S.
Diag(SR.
getEnd(), diag::err_init_reference_member_uninitialized)
5767 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
true);
5768 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr))
5772 EntityIndexToProcess++;
5774 ResultType = Entity.
getType();
5779 if (EntityIndexToProcess < Args.size()) {
5784 SourceRange ExcessInitSR(Args[EntityIndexToProcess]->getBeginLoc(),
5785 Args.back()->getEndLoc());
5786 S.
Diag(Kind.getLocation(), diag::err_excess_initializers)
5787 << InitKind << ExcessInitSR;
5801 CPLIE->setArrayFiller(ArrayFiller);
5802 if (InitializedFieldInUnion)
5803 CPLIE->setInitializedFieldInUnion(InitializedFieldInUnion);
5805 S.
Diag(Kind.getLocation(),
5806 diag::warn_cxx17_compat_aggregate_init_paren_list)
5807 << Kind.getLocation() << SR << ResultType;
5819 bool TopLevelOfInitList) {
5820 assert(!DestType->
isReferenceType() &&
"References are handled elsewhere");
5823 "Must have a class type to perform a user-defined conversion");
5833 bool AllowExplicit = Kind.AllowExplicit();
5839 = cast<CXXRecordDecl>(DestRecordType->getDecl());
5845 if (!Info.Constructor)
5848 if (!Info.Constructor->isInvalidDecl() &&
5849 Info.Constructor->isConvertingConstructor(
true)) {
5850 if (Info.ConstructorTmpl)
5852 Info.ConstructorTmpl, Info.FoundDecl,
5855 false, AllowExplicit);
5860 false, AllowExplicit);
5876 = cast<CXXRecordDecl>(SourceRecordType->getDecl());
5878 const auto &Conversions =
5880 for (
auto I = Conversions.begin(),
E = Conversions.end(); I !=
E; ++I) {
5883 if (isa<UsingShadowDecl>(
D))
5884 D = cast<UsingShadowDecl>(
D)->getTargetDecl();
5891 Conv = cast<CXXConversionDecl>(
D);
5895 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
5896 CandidateSet, AllowExplicit, AllowExplicit);
5899 DestType, CandidateSet, AllowExplicit,
5925 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
5927 if (isa<CXXConstructorDecl>(
Function)) {
5933 HadMultipleCandidates);
5962 HadMultipleCandidates);
5975 Function->getReturnType()->isReferenceType() ||
5985 if (Best->FinalConversion.First || Best->FinalConversion.Second ||
5986 Best->FinalConversion.Third) {
5989 ICS.
Standard = Best->FinalConversion;
6007 isa<CXXBoolLiteralExpr>(
Init) &&
6008 !cast<CXXBoolLiteralExpr>(
Init)->getValue() &&
6017 bool isAddressOf,
bool &isWeakAccess) {
6023 if (op->getOpcode() == UO_AddrOf)
6028 }
else if (
CastExpr *ce = dyn_cast<CastExpr>(e)) {
6029 switch (ce->getCastKind()) {
6032 case CK_LValueBitCast:
6036 case CK_ArrayToPointerDecay:
6039 case CK_NullToPointer:
6047 }
else if (isa<DeclRefExpr>(e)) {
6051 isWeakAccess =
true;
6055 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
6069 }
else if (isa<ArraySubscriptExpr>(e)) {
6085 bool isWeakAccess =
false;
6089 if (S.
getLangOpts().ObjCAutoRefCount && isWeakAccess)
6121 bool ArrayDecay =
false;
6126 ArgPointee = ArgArrayType->getElementType();
6138 bool ShouldCopy =
true;
6209 "cl_intel_device_side_avc_motion_estimation", S.
getLangOpts()) &&
6211 if (DestType->isOCLIntelSubgroupAVCMcePayloadType() ||
6212 DestType->isOCLIntelSubgroupAVCMceResultType())
6226 MultiExprArg Args,
bool TopLevelOfInitList,
bool TreatUnavailableAsInvalid)
6230 TreatUnavailableAsInvalid);
6236 auto *DRE = dyn_cast<DeclRefExpr>(
E);
6237 if (!DRE || !isa<FunctionDecl>(DRE->getDecl()))
6241 cast<FunctionDecl>(DRE->getDecl()));
6258 return isa<DecompositionDecl>(Entity.
getDecl());
6284 bool TopLevelOfInitList,
6285 bool TreatUnavailableAsInvalid) {
6292 for (
unsigned I = 0,
E = Args.size(); I !=
E; ++I)
6293 if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
6300 Args[I] = result.
get();
6322 if (Args.size() == 1) {
6340 TreatUnavailableAsInvalid);
6352 if (Args.size() != 1)
6358 else if (isa<InitListExpr>(Args[0]))
6362 TopLevelOfInitList);
6388 if (
Initializer && isa<VariableArrayType>(DestAT)) {
6420 if (
Initializer && isa<ConstantArrayType>(DestAT) &&
6438 Expr *OVEAsExpr = &OVE;
6440 TreatUnavailableAsInvalid);
6450 isa<CompoundLiteralExpr>(
Initializer->IgnoreParens()) &&
6468 *
this, TreatUnavailableAsInvalid);
6470 }
else if (S.
getLangOpts().CPlusPlus20 && !TopLevelOfInitList &&
6486 bool allowObjCWritebackConversion = S.
getLangOpts().ObjCAutoRefCount &&
6495 assert(
Initializer &&
"Initializer must be non-null");
6497 if (allowObjCWritebackConversion &&
6523 SourceType, DestType))))) {
6530 if (
const auto *RD =
6535 S.
getLangOpts().CPlusPlus20 && RD && RD->hasDefinition() &&
6536 RD->isAggregate() &&
Failed() &&
6549 S, Kind.getLocation(), Best);
6567 assert(
Initializer &&
"Initializer must be non-null");
6569 TopLevelOfInitList);
6574 assert(Args.size() >= 1 &&
"Zero-argument case handled above");
6584 for (
auto *Arg : Args) {
6585 if (Arg->getType()->isExtVectorType()) {
6588 for (
unsigned Idx = 0; Idx < Elm; ++Idx) {
6594 VTy->getElementType(), Arg->
getValueKind(), Arg->getObjectKind(),
6598 InitArgs.emplace_back(Arg);
6608 if (Args.size() > 1) {
6611 }
else if (isa<InitListExpr>(Args[0])) {
6619 assert(
Initializer &&
"Initializer must be non-null");
6622 bool NeedAtomicConversion =
false;
6626 Atomic->getValueType())) {
6627 DestType =
Atomic->getValueType();
6628 NeedAtomicConversion =
true;
6633 TopLevelOfInitList);
6635 if (!
Failed() && NeedAtomicConversion)
6662 Sema::AllowedExplicit::None,
6664 Kind.isCStyleOrFunctionalCast(),
6665 allowObjCWritebackConversion);
6673 bool ShouldCopy =
true;
6689 }
else if (ICS.
isBad()) {
6697 else if (
Initializer->getType()->isFunctionType() &&
6710 for (
auto &S : Steps)
6768 llvm_unreachable(
"Invalid EntityKind!");
6802 llvm_unreachable(
"missed an InitializedEntity kind?");
6836 llvm_unreachable(
"missed an InitializedEntity kind?");
6875 llvm_unreachable(
"missed an InitializedEntity kind?");
6902 bool IsExtraneousCopy) {
6927 S,
Loc, CurInitExpr, CandidateSet,
T, Ctors, Best,
6939 ? diag::ext_rvalue_to_reference_temp_copy_no_viable
6940 : diag::err_temp_copy_no_viable)
6958 S.
Diag(
Loc, diag::err_temp_copy_deleted)
6965 bool HadMultipleCandidates = CandidateSet.
size() > 1;
6974 if (IsExtraneousCopy) {
6985 for (
unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
6988 diag::err_call_incomplete_argument))
7029 Best->Function->getParamDecl(0)->getType().getNonReferenceType(),
7034 Loc,
T, Best->FoundDecl, Constructor, Elidable, ConstructorArgs,
7035 HadMultipleCandidates,
7051 Expr *CurInitExpr) {
7070 S,
Loc, CurInitExpr, CandidateSet, CurInitExpr->
getType(), Ctors, Best,
7083 Best->FoundDecl, Entity,
Diag);
7104void InitializationSequence::PrintInitLocationNote(
Sema &S,
7119 diag::note_method_return_type_change)
7137 switch (Kind.getKind()) {
7143 return NumArgs != 1;
7155 bool &ConstructorInitRequiresZeroInit,
7156 bool IsListInitialization,
7157 bool IsStdInitListInitialization,
7160 unsigned NumArgs = Args.size();
7168 ? Kind.getEqualLoc()
7169 : Kind.getLocation();
7175 assert(Constructor->getParent() &&
"No parent class for constructor.");
7176 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
7177 Constructor->isTrivial() && !Constructor->isUsed(
false)) {
7192 bool AllowExplicitConv =
7193 Kind.AllowExplicit() && !Kind.isCopyInit() && Args.size() == 1 &&
7198 if (NumArgs == 1 && !Kind.isExplicitCast())
7200 Entity.
getType(), Args.front()->getType(), Kind.getLocation());
7205 ConstructorArgs, AllowExplicitConv,
7206 IsListInitialization))
7220 : Kind.getParenOrBraceRange();
7223 if (
auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(
7233 ConstructorArgs, ParenOrBraceRange, HadMultipleCandidates,
7234 IsListInitialization, IsStdInitListInitialization,
7235 ConstructorInitRequiresZeroInit),
7251 if (IsListInitialization)
7252 ParenOrBraceRange =
SourceRange(LBraceLoc, RBraceLoc);
7254 ParenOrBraceRange = Kind.getParenOrBraceRange();
7263 HadMultipleCandidates,
7264 IsListInitialization,
7265 IsStdInitListInitialization,
7266 ConstructorInitRequiresZeroInit,
7274 HadMultipleCandidates,
7275 IsListInitialization,
7276 IsStdInitListInitialization,
7277 ConstructorInitRequiresZeroInit,
7308 const Expr *PostInit);
7315 bool IsReturnStmt) {
7326 unsigned DiagID = 0;
7356 if (VD->
hasAttr<BlocksAttr>())
7369 if (isa<ParmVarDecl>(VD))
7370 DiagID = diag::warn_redundant_move_on_return;
7372 DiagID = diag::warn_pessimizing_move_on_return;
7374 DiagID = diag::warn_pessimizing_move_on_initialization;
7416 if (UO->getOpcode() == UO_Deref &&
7417 UO->getSubExpr()->IgnoreParenCasts()->
7420 S.
PDiag(diag::warn_binding_null_to_reference)
7421 << UO->getSubExpr()->getSourceRange());
7427 bool BoundToLvalueReference) {
7440 Record.ForRangeLifetimeExtendTemps.push_back(MTE);
7472 if (!PointeeTy.isNull() &&
7473 PointeeTy.getAddressSpace() != ExprPointeeTy.getAddressSpace())
7474 CK = CK_AddressSpaceConversion;
7476 CK = CK_AddressSpaceConversion;
7491 if (!ZeroInitializationFixit.empty()) {
7493 const auto *VD = dyn_cast_or_null<VarDecl>(
D);
7499 if (!DestType->
isRecordType() && VD && VD->isConstexpr()) {
7501 S.
Diag(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)
7504 ZeroInitializationFixit);
7506 unsigned DiagID = diag::err_default_init_const;
7508 DiagID = diag::ext_default_init_const;
7510 S.
Diag(Kind.getLocation(), DiagID)
7513 ZeroInitializationFixit);
7533 if (isa<InitListExpr>((
Expr *)Args[0])) {
7537 if (
auto *DD = dyn_cast_or_null<DeclaratorDecl>(Entity.
getDecl())) {
7539 TypeLoc TL = TInfo->getTypeLoc();
7542 Brackets = ArrayLoc.getBracketsRange();
7549 ArrayT->getSizeModifier(),
7550 ArrayT->getIndexTypeCVRQualifiers(),
7557 !Kind.isExplicitCast()) {
7559 SourceRange ParenRange = Kind.getParenOrBraceRange();
7564 Kind.isExplicitCast() ||
7574 Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
7580 S.
Diag(
Init->getBeginLoc(), diag::warn_cxx98_compat_reference_list_init)
7581 <<
Init->getSourceRange();
7584 if (S.
getLangOpts().MicrosoftExt && Args.size() == 1 &&
7590 S.
Diag(
Init->getBeginLoc(), diag::ext_init_from_predefined) <<
Init;
7601 S.
Diag(Args[0]->getBeginLoc(), diag::err_opencl_atomic_init)
7621 isa<InitListExpr>(Args[0]);
7622 (void)IsHLSLVectorInit;
7627 switch (Steps.front().Kind) {
7661 assert(Args.size() == 1 || IsHLSLVectorInit);
7680 isa_and_nonnull<InitListExpr>(CurInit.
get()));
7685 auto checkAbstractType = [&](
QualType T) ->
bool {
7690 diag::err_allocation_of_abstract_type);
7695 bool ConstructorInitRequiresZeroInit =
false;
7728 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
7740 CK_DerivedToBase, CurInit.
get(),
7756 if (
auto *DRE = dyn_cast<DeclRefExpr>(CurInit.
get()->
IgnoreParens())) {
7757 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
7770 assert(CurInit.
get()->
isPRValue() &&
"not a temporary");
7828 bool CreatedObject =
false;
7844 Loc,
Step->
Type, FoundFn, Constructor, ConstructorArgs,
7845 HadMultipleCandidates,
7857 CastKind = CK_ConstructorConversion;
7858 CreatedObject =
true;
7868 HadMultipleCandidates);
7872 CastKind = CK_UserDefinedConversion;
7876 if (CreatedObject && checkAbstractType(CurInit.
get()->
getType()))
7897 S.
PDiag(diag::err_access_dtor_temp) <<
T);
7921 "function reference should be lvalue");
7927 assert(CurInit.
get()->
isPRValue() &&
"cannot convert glvalue to atomic");
7935 if (
const auto *FromPtrType =
7938 if (FromPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
7939 !ToPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
7942 if (!Kind.isStaticCast()) {
7944 diag::warn_noderef_to_dereferenceable_pointer)
7963 CurInit = CurInitExprRes;
7984 InitListChecker PerformInitList(S, InitEntity,
7985 InitList, Ty,
false,
7987 if (PerformInitList.HadError())
7995 if ((*ResultType)->isRValueReferenceType())
7997 else if ((*ResultType)->isLValueReferenceType())
8004 PerformInitList.getFullyStructuredList();
8008 : StructuredInitList;
8025 assert(Args.size() == 1 &&
"expected a single argument for list init");
8027 S.
Diag(InitList->
getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
8033 ConstructorInitRequiresZeroInit,
8042 CurInit = cast<InitListExpr>(CurInit.
get())->getInit(0);
8071 bool IsStdInitListInit =
8075 ? Kind.getParenOrBraceRange()
8078 S, UseTemporary ? TempEntity : Entity, Kind,
8080 ConstructorInitRequiresZeroInit,
8091 if (NextStep != StepEnd &&
8096 ConstructorInitRequiresZeroInit =
true;
8099 !Kind.isImplicitValueInit()) {
8103 Kind.getRange().getBegin());
8107 Kind.getRange().getEnd());
8137 CurInit = CurInitExprRes;
8152 S.
Diag(Kind.getLocation(), diag::err_c23_constexpr_pointer_not_null);
8159 InitialCurInit.
get(),
8162 PrintInitLocationNote(S, Entity);
8164 }
else if (Complained)
8165 PrintInitLocationNote(S, Entity);
8181 CK_ObjCObjectLValueCast,
8193 BaseExpr, Kind.getLocation(), IndexExpr, Kind.getLocation());
8194 ArrayLoopCommonExprs.push_back(BaseExpr);
8199 assert(!ArrayLoopCommonExprs.empty() &&
8200 "mismatched SK_ArrayLoopIndex and SK_ArrayLoopInit");
8201 Expr *Common = ArrayLoopCommonExprs.pop_back_val();
8210 S.
Diag(Kind.getLocation(), diag::ext_array_init_copy)
8224 IncompleteDest->getElementType(), ConstantSource->getSize(),
8234 S.
Diag(Kind.getLocation(), diag::ext_array_init_parens)
8254 diag::warn_cxx98_compat_initializer_list_init)
8267 [[maybe_unused]]
bool IsStdInitializerList =
8269 assert(IsStdInitializerList &&
8270 "StdInitializerList step to non-std::initializer_list");
8274 "std::initializer_list should have already be "
8275 "complete/instantiated by this point");
8277 auto InvalidType = [&] {
8279 diag::err_std_initializer_list_malformed)
8286 return InvalidType();
8289 if (Field ==
Record->field_end())
8290 return InvalidType();
8293 if (!Field->getType()->isPointerType() ||
8296 return InvalidType();
8298 if (++Field ==
Record->field_end())
8299 return InvalidType();
8302 if (
const auto *PT = Field->getType()->getAs<
PointerType>()) {
8305 return InvalidType();
8307 if (Field->isBitField() ||
8309 return InvalidType();
8312 if (++Field !=
Record->field_end())
8313 return InvalidType();
8340 "Sampler initialization on non-sampler type.");
8346 S.
Diag(Kind.getLocation(), diag::err_sampler_argument_required)
8350 auto Var = cast<VarDecl>(DRE->getDecl());
8353 if (!Var->hasGlobalStorage()) {
8365 if (!Var->getInit() || !isa<ImplicitCastExpr>(Var->getInit()))
8367 Init = cast<ImplicitCastExpr>(
const_cast<Expr*
>(
8368 Var->getInit()))->getSubExpr();
8369 SourceType =
Init->getType();
8376 if (!
Init->isConstantInitializer(S.
Context,
false))
8381 S.
Diag(Kind.getLocation(), diag::err_sampler_initializer_not_integer)
8389 const uint64_t SamplerValue =
Result.getLimitedValue();
8396 unsigned AddressingMode = (0x0E & SamplerValue) >> 1;
8397 unsigned FilterMode = (0x30 & SamplerValue) >> 4;
8398 if (FilterMode != 1 && FilterMode != 2 &&
8400 "cl_intel_device_side_avc_motion_estimation", S.
getLangOpts()))
8401 S.
Diag(Kind.getLocation(),
8402 diag::warn_sampler_initializer_invalid_bits)
8404 if (AddressingMode > 4)
8405 S.
Diag(Kind.getLocation(),
8406 diag::warn_sampler_initializer_invalid_bits)
8407 <<
"Addressing Mode";
8413 CK_IntToOCLSampler);
8419 "Wrong type for initialization of OpenCL opaque type.");
8422 CK_ZeroToOCLOpaqueType,
8430 if (CurInit.
get() && ResultType)
8451 cast<FieldDecl>(Entity.
getDecl())->isBitField())
8452 S.CheckBitFieldInitialization(Kind.getLocation(),
8467 S.
Diag(
Loc, diag::err_reference_without_init)
8468 <<
T.getNonReferenceType();
8476 for (
const auto *FI : RD->
fields()) {
8477 if (FI->isUnnamedBitField())
8481 S.
Diag(
Loc, diag::note_value_initialization_here) << RD;
8486 for (
const auto &BI : RD->
bases()) {
8488 S.
Diag(
Loc, diag::note_value_initialization_here) << RD;
8523 if (fromDecl && destDecl && fromDecl->getDeclKind() == Decl::CXXRecord &&
8524 destDecl->getDeclKind() == Decl::CXXRecord &&
8525 !fromDecl->isInvalidDecl() && !destDecl->isInvalidDecl() &&
8526 !fromDecl->hasDefinition() &&
8529 S.
Diag(fromDecl->getLocation(), diag::note_forward_class_conversion)
8559 S.
Diag(
Loc, diag::note_in_reference_temporary_list_initializer) <<
T;
8563 InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
8566 assert(DiagnoseInitList.HadError() &&
8567 "Inconsistent init list check result.");
8582 if (Args.size() == 1) {
8583 auto *List = dyn_cast<InitListExpr>(Args[0]);
8584 if (List && List->getNumInits() == 1)
8585 OnlyArg = List->getInit(0);
8594 if (
Expr *Resolved =
8614 assert(Diagnosed &&
"couldn't find uninitialized reference to diagnose");
8617 S.
Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
8618 <<
SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
8621 S.
Diag(Kind.getLocation(), diag::err_list_init_in_parens)
8622 << 1 << Entity.
getType() << Args[0]->getSourceRange();
8626 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
8629 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
8632 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
8635 S.
Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
8638 S.
Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
8641 S.
Diag(Kind.getLocation(),
8642 diag::err_array_init_incompat_wide_string_into_wchar);
8645 S.
Diag(Kind.getLocation(),
8646 diag::err_array_init_plain_string_into_char8_t);
8647 S.
Diag(Args.front()->getBeginLoc(),
8648 diag::note_array_init_plain_string_into_char8_t)
8652 S.
Diag(Kind.getLocation(), diag::err_array_init_utf8_string_into_char)
8657 S.
Diag(Kind.getLocation(),
8659 ? diag::err_array_init_different_type
8660 : diag::err_array_init_non_constant_array))
8663 << Args[0]->getSourceRange();
8667 S.
Diag(Kind.getLocation(), diag::err_variable_object_no_init)
8668 << Args[0]->getSourceRange();
8681 auto *FD = cast<FunctionDecl>(cast<DeclRefExpr>(OnlyArg)->getDecl());
8689 switch (FailedOverloadResult) {
8696 ? (S.
PDiag(diag::err_typecheck_ambiguous_condition)
8697 << OnlyArg->
getType() << DestType
8698 << Args[0]->getSourceRange())
8699 : (S.
PDiag(diag::err_ref_init_ambiguous)
8700 << DestType << OnlyArg->
getType()
8701 << Args[0]->getSourceRange())),
8709 diag::err_typecheck_nonviable_condition_incomplete,
8710 OnlyArg->
getType(), Args[0]->getSourceRange()))
8711 S.
Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
8713 << OnlyArg->
getType() << Args[0]->getSourceRange()
8725 S.
Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
8727 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef())
8728 << Args[0]->getSourceRange();
8732 llvm_unreachable(
"Inconsistent overload resolution?");
8738 llvm_unreachable(
"Conversion did not fail!");
8743 if (isa<InitListExpr>(Args[0])) {
8744 S.
Diag(Kind.getLocation(),
8745 diag::err_lvalue_reference_bind_to_initlist)
8748 << Args[0]->getSourceRange();
8754 S.
Diag(Kind.getLocation(),
8756 ? diag::err_lvalue_reference_bind_to_temporary
8757 : diag::err_lvalue_reference_bind_to_unrelated)
8761 << Args[0]->getSourceRange();
8766 FieldDecl *BitField = Args[0]->getSourceBitField();
8767 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
8770 << (BitField !=
nullptr)
8771 << Args[0]->getSourceRange();
8778 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
8780 << Args[0]->getSourceRange();
8784 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_matrix_element)
8789 S.
Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
8791 << Args[0]->getSourceRange();
8795 S.
Diag(Kind.getLocation(), diag::err_reference_bind_temporary_addrspace)
8796 << DestType << Args[0]->getSourceRange();
8807 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
8808 << NonRefType << SourceType << 1
8809 << Args[0]->getSourceRange();
8811 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
8812 << NonRefType << SourceType << 0
8818 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
8819 << NonRefType << SourceType << 2
8820 << Args[0]->getSourceRange();
8825 S.
Diag(Kind.getLocation(), diag::err_reference_bind_failed)
8830 << Args[0]->getSourceRange();
8841 << Args[0]->getSourceRange();
8843 S.
Diag(Kind.getLocation(), PDiag);
8855 auto *InitList = dyn_cast<InitListExpr>(Args[0]);
8856 if (InitList && InitList->getNumInits() >= 1) {
8857 R =
SourceRange(InitList->getInit(0)->getEndLoc(), InitList->getEndLoc());
8859 assert(Args.size() > 1 &&
"Expected multiple initializers!");
8860 R =
SourceRange(Args.front()->getEndLoc(), Args.back()->getEndLoc());
8864 if (Kind.isCStyleOrFunctionalCast())
8865 S.
Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
8868 S.
Diag(Kind.getLocation(), diag::err_excess_initializers)
8874 S.
Diag(Kind.getLocation(), diag::err_list_init_in_parens)
8875 << 0 << Entity.
getType() << Args[0]->getSourceRange();
8879 S.
Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
8884 S.
Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
8885 << (DestType->
isRecordType()) << DestType << Args[0]->getSourceRange();
8893 SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
8896 assert(Args.size() == 1 &&
8897 "List construction from other than 1 argument.");
8904 switch (FailedOverloadResult) {
8908 S.
PDiag(diag::err_ovl_ambiguous_init)
8909 << DestType << ArgsRange),
8926 if (
auto Inherited = Constructor->getInheritedConstructor())
8927 InheritedFrom = Inherited.getShadowDecl()->getNominatedBaseClass();
8929 S.
Diag(Kind.getLocation(), diag::err_missing_default_ctor)
8930 << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
8942 S.
Diag(Kind.getLocation(), diag::err_missing_default_ctor)
8943 << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
8949 diag::note_member_declared_at);
8954 diag::note_previous_decl)
8963 S.
PDiag(diag::err_ovl_no_viable_function_in_init)
8964 << DestType << ArgsRange),
8973 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
8974 << DestType << ArgsRange;
8975 llvm_unreachable(
"Inconsistent overload resolution?");
8983 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
8984 << llvm::to_underlying(
8986 << DestType << ArgsRange;
8989 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
8990 << DestType << (Msg !=
nullptr)
8991 << (Msg ? Msg->
getString() : StringRef()) << ArgsRange;
8999 llvm_unreachable(
"Conversion did not fail!");
9011 S.
Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
9012 << (Constructor->getInheritedConstructor() ? 2 :
9013 Constructor->isImplicit() ? 1 : 0)
9019 }
else if (
const auto *VD = dyn_cast_if_present<VarDecl>(Entity.
getDecl());
9020 VD && VD->isConstexpr()) {
9021 S.
Diag(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)
9024 S.
Diag(Kind.getLocation(), diag::err_default_init_const)
9031 diag::err_init_incomplete_type);
9047 S.
Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
9048 << Args[0]->getSourceRange();
9053 assert(Ovl ==
OR_Success &&
"Inconsistent overload resolution");
9056 diag::note_explicit_ctor_deduction_guide_here) <<
false;
9067 S.
Diag(Kind.getLocation(), diag::err_designated_init_for_non_aggregate)
9072 PrintInitLocationNote(S, Entity);
9079 OS <<
"Failed sequence: ";
9082 OS <<
"too many initializers for reference";
9086 OS <<
"parenthesized list init for reference";
9090 OS <<
"array requires initializer list";
9094 OS <<
"address of unaddressable function was taken";
9098 OS <<
"array requires initializer list or string literal";
9102 OS <<
"array requires initializer list or wide string literal";
9106 OS <<
"narrow string into wide char array";
9110 OS <<
"wide string into char array";
9114 OS <<
"incompatible wide string into wide char array";
9118 OS <<
"plain string literal into char8_t array";
9122 OS <<
"u8 string literal into char array";
9126 OS <<
"array type mismatch";
9130 OS <<
"non-constant array initializer";
9134 OS <<
"address of overloaded function failed";
9138 OS <<
"overload resolution for reference initialization failed";
9142 OS <<
"non-const lvalue reference bound to temporary";
9146 OS <<
"non-const lvalue reference bound to bit-field";
9150 OS <<
"non-const lvalue reference bound to vector element";
9154 OS <<
"non-const lvalue reference bound to matrix element";
9158 OS <<
"non-const lvalue reference bound to unrelated type";
9162 OS <<
"rvalue reference bound to an lvalue";
9166 OS <<
"reference initialization drops qualifiers";
9170 OS <<
"reference with mismatching address space bound to temporary";
9174 OS <<
"reference initialization failed";
9178 OS <<
"conversion failed";
9182 OS <<
"conversion from property failed";
9186 OS <<
"too many initializers for scalar";
9190 OS <<
"parenthesized list init for reference";
9194 OS <<
"referencing binding to initializer list";
9198 OS <<
"initializer list for non-aggregate, non-scalar type";
9202 OS <<
"overloading failed for user-defined conversion";
9206 OS <<
"constructor overloading failed";
9210 OS <<
"default initialization of a const variable";
9214 OS <<
"initialization of incomplete type";
9218 OS <<
"list initialization checker failure";
9222 OS <<
"variable length array has an initializer";
9226 OS <<
"initializer expression isn't contextually valid";
9230 OS <<
"list constructor overloading failed";
9234 OS <<
"list copy initialization chose explicit constructor";
9238 OS <<
"parenthesized list initialization failed";
9242 OS <<
"designated initializer for non-aggregate type";
9250 OS <<
"Dependent sequence\n";
9254 OS <<
"Normal sequence: ";
9265 OS <<
"resolve address of overloaded function";
9269 OS <<
"derived-to-base (prvalue)";
9273 OS <<
"derived-to-base (xvalue)";
9277 OS <<
"derived-to-base (lvalue)";
9281 OS <<
"bind reference to lvalue";
9285 OS <<
"bind reference to a temporary";
9289 OS <<
"final copy in class direct-initialization";
9293 OS <<
"extraneous C++03 copy to temporary";
9297 OS <<
"user-defined conversion via " << *S->Function.Function;
9301 OS <<
"qualification conversion (prvalue)";
9305 OS <<
"qualification conversion (xvalue)";
9309 OS <<
"qualification conversion (lvalue)";
9313 OS <<
"function reference conversion";
9317 OS <<
"non-atomic-to-atomic conversion";
9321 OS <<
"implicit conversion sequence (";
9327 OS <<
"implicit conversion sequence with narrowing prohibited (";
9333 OS <<
"list aggregate initialization";
9337 OS <<
"unwrap reference initializer list";
9341 OS <<
"rewrap reference initializer list";
9345 OS <<
"constructor initialization";
9349 OS <<
"list initialization via constructor";
9353 OS <<
"zero initialization";
9357 OS <<
"C assignment";
9361 OS <<
"string initialization";
9365 OS <<
"Objective-C object conversion";
9369 OS <<
"indexing for array initialization loop";
9373 OS <<
"array initialization loop";
9377 OS <<
"array initialization";
9381 OS <<
"array initialization (GNU extension)";
9385 OS <<
"parenthesized array initialization";
9389 OS <<
"pass by indirect copy and restore";
9393 OS <<
"pass by indirect restore";
9397 OS <<
"Objective-C object retension";
9401 OS <<
"std::initializer_list from initializer list";
9405 OS <<
"list initialization from std::initializer_list";
9409 OS <<
"OpenCL sampler_t from integer constant";
9413 OS <<
"OpenCL opaque type from zero";
9416 OS <<
"initialization from a parenthesized list of values";
9420 OS <<
" [" << S->Type <<
']';
9434 const Expr *PostInit) {
9450 auto MakeDiag = [&](
bool IsConstRef,
unsigned DefaultDiagID,
9451 unsigned ConstRefDiagID,
unsigned WarnDiagID) {
9454 if (L.CPlusPlus11 &&
9456 DiagID = IsConstRef ? ConstRefDiagID : DefaultDiagID;
9458 DiagID = WarnDiagID;
9478 MakeDiag(
T != EntityType, diag::ext_init_list_type_narrowing,
9479 diag::ext_init_list_type_narrowing_const_reference,
9480 diag::warn_init_list_type_narrowing)
9482 <<
T.getLocalUnqualifiedType();
9489 diag::ext_init_list_constant_narrowing,
9490 diag::ext_init_list_constant_narrowing_const_reference,
9491 diag::warn_init_list_constant_narrowing)
9500 diag::ext_init_list_variable_narrowing,
9501 diag::ext_init_list_variable_narrowing_const_reference,
9502 diag::warn_init_list_variable_narrowing)
9510 llvm::raw_svector_ostream OS(StaticCast);
9511 OS <<
"static_cast<";
9518 OS << *TT->getDecl();
9527 S.
Diag(PostInit->
getBeginLoc(), diag::note_init_list_narrowing_silence)
9538 Init->IgnoreParenImpCasts(), ToType,
false,
9539 Sema::AllowedExplicit::None,
9555 S.
Diag(
Init->getBeginLoc(), diag::err_c23_constexpr_init_not_representable)
9556 <<
Value.getAsString(S.
Context, PreNarrowingType) << ToType;
9561 S.
Diag(
Init->getBeginLoc(), diag::err_c23_constexpr_init_type_mismatch)
9562 << ToType << FromType;
9572 llvm_unreachable(
"unhandled case in switch");
9584 for (
unsigned I = 0, N = SE->
getLength(); I != N; ++I) {
9589 diag::err_c23_constexpr_init_not_representable)
9603 if (
Init.isInvalid())
9607 assert(InitE &&
"No initialization expression");
9612 return !
Seq.Failed();
9619 bool TopLevelOfInitList,
9620 bool AllowExplicit) {
9621 if (
Init.isInvalid())
9625 assert(InitE &&
"No initialization expression?");
9635 const bool ShouldTrackCopy =
9637 if (ShouldTrackCopy) {
9639 Seq.SetOverloadFailure(
9645 const auto LastStep =
Seq.step_end() - 1;
9646 assert(LastStep->Kind ==
9650 llvm::find_if(
Seq.getFailedCandidateSet(),
9652 return Candidate.Viable &&
9653 Candidate.Function == Function &&
9654 Candidate.Conversions.size() > 0;
9656 if (Candidate !=
Seq.getFailedCandidateSet().end() &&
9658 Candidate->
Viable =
false;
9662 Function->getParamDecl(0)->getType());
9670 if (ShouldTrackCopy)
9679 auto NotSpecialization = [&] (
const CXXRecordDecl *Candidate) {
9680 auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Candidate);
9683 return !(NotSpecialization(RD) && RD->
forallBases(NotSpecialization));
9689 auto *DeducedTST = dyn_cast<DeducedTemplateSpecializationType>(
9691 assert(DeducedTST &&
"not a deduced template specialization type");
9702 if (
auto *
AliasTemplate = dyn_cast_or_null<TypeAliasTemplateDecl>(
9704 Diag(Kind.getLocation(),
9705 diag::warn_cxx17_compat_ctad_for_alias_templates);
9708 ->getUnderlyingType()
9709 .getCanonicalType();
9713 if (
const auto *TST =
9715 Template = dyn_cast_or_null<ClassTemplateDecl>(
9716 TST->getTemplateName().getAsTemplateDecl());
9717 }
else if (
const auto *RT = UnderlyingType->getAs<
RecordType>()) {
9721 if (
const auto *CTSD = llvm::dyn_cast<ClassTemplateSpecializationDecl>(
9722 RT->getAsCXXRecordDecl()))
9723 Template = CTSD->getSpecializedTemplate();
9728 Diag(Kind.getLocation(),
9729 diag::err_deduced_non_class_or_alias_template_specialization_type)
9739 diag::warn_cxx14_compat_class_template_argument_deduction)
9767 ? dyn_cast<InitListExpr>(Inits[0])
9783 bool AllowExplicit = !Kind.isCopyInit() ||
ListInit;
9789 bool OnlyListConstructors,
9790 bool AllowAggregateDeductionCandidate) {
9796 if (!AllowExplicit) {
9803 if (GD->getMinRequiredArguments() > 1 ||
9804 (GD->getNumParams() == 0 && !GD->isVariadic()))
9814 if (!AllowAggregateDeductionCandidate &&
9829 for (
Expr *
E : Inits)
9830 if (
auto *DI = dyn_cast<DesignatedInitExpr>(
E))
9831 TmpInits.push_back(DI->getInit());
9833 TmpInits.push_back(
E);
9835 TD, FoundDecl,
nullptr, TmpInits, Candidates,
9837 false, AllowExplicit, ADLCallKind::NotADL,
9838 {}, AllowAggregateDeductionCandidate);
9842 false, AllowExplicit);
9846 bool FoundDeductionGuide =
false;
9848 auto TryToResolveOverload =
9851 bool HasAnyDeductionGuide =
false;
9854 auto *Pattern = Template;
9855 while (Pattern->getInstantiatedFromMemberTemplate()) {
9856 if (Pattern->isMemberSpecialization())
9858 Pattern = Pattern->getInstantiatedFromMemberTemplate();
9861 auto *RD = cast<CXXRecordDecl>(Pattern->getTemplatedDecl());
9867 InitListChecker CheckInitList(*
this, Entity,
ListInit, Ty, ElementTypes);
9868 if (!CheckInitList.HadError()) {
9877 for (
int I = 0,
E =
ListInit->getNumInits();
9878 I <
E && !isa<PackExpansionType>(ElementTypes[I]); ++I)
9879 if (ElementTypes[I]->isArrayType()) {
9880 if (isa<InitListExpr, DesignatedInitExpr>(
ListInit->getInit(I)))
9882 else if (isa<StringLiteral>(
9883 ListInit->getInit(I)->IgnoreParenImpCasts()))
9890 LookupTemplateDecl, ElementTypes,
9894 OnlyListConstructors,
9896 HasAnyDeductionGuide =
true;
9901 for (
auto I = Guides.
begin(),
E = Guides.
end(); I !=
E; ++I) {
9906 auto *TD = dyn_cast<FunctionTemplateDecl>(
D);
9907 auto *GD = dyn_cast_if_present<CXXDeductionGuideDecl>(
9912 if (!GD->isImplicit())
9913 HasAnyDeductionGuide =
true;
9915 addDeductionCandidate(TD, GD, I.getPair(), OnlyListConstructors,
9930 }
else if (Inits.size()) {
9935 Inits, Inits.back()->getEndLoc());
9936 SynthesizeAggrGuide(&TempListInit);
9940 FoundDeductionGuide = FoundDeductionGuide || HasAnyDeductionGuide;
9950 bool TryListConstructors =
true;
9956 auto *FD = dyn_cast<FunctionDecl>(
D->getUnderlyingDecl());
9957 if (FD && FD->getMinRequiredArguments() == 0) {
9958 TryListConstructors =
false;
9962 }
else if (
ListInit->getNumInits() == 1) {
9970 if (!isa<InitListExpr>(
E) && RD &&
9973 TryListConstructors =
false;
9976 if (TryListConstructors)
9977 Result = TryToResolveOverload(
true);
9986 Result = TryToResolveOverload(
false);
9996 PDiag(diag::err_deduced_class_template_ctor_ambiguous)
10003 cast<ClassTemplateDecl>(Template)->getTemplatedDecl();
10008 Kind.getLocation(),
10009 PDiag(
Complete ? diag::err_deduced_class_template_ctor_no_viable
10010 : diag::err_deduced_class_template_incomplete)
10020 Diag(Kind.getLocation(), diag::err_deduced_class_template_deleted)
10030 if (Kind.isCopyInit() &&
ListInit &&
10031 cast<CXXDeductionGuideDecl>(Best->Function)->isExplicit()) {
10032 bool IsDeductionGuide = !Best->Function->isImplicit();
10033 Diag(Kind.getLocation(), diag::err_deduced_class_template_explicit)
10035 Diag(Best->Function->getLocation(),
10036 diag::note_explicit_ctor_deduction_guide_here)
10037 << IsDeductionGuide;
10054 diag::warn_cxx14_compat_class_template_argument_deduction)
10059 if (!FoundDeductionGuide) {
10061 diag::warn_ctad_maybe_unsupported)
10063 Diag(Template->getLocation(), diag::note_suppress_ctad_maybe_unsupported);
Defines the clang::ASTContext interface.
static bool isUnsigned(SValBuilder &SVB, NonLoc Value)
static bool isRValueRef(QualType ParamType)
Defines the clang::Expr interface and subclasses for C++ expressions.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Record Record
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
static void CheckForNullPointerDereference(Sema &S, Expr *E)
static bool isExprAnUnaddressableFunction(Sema &S, const Expr *E)
Tries to get a FunctionDecl out of E.
static void updateStringLiteralType(Expr *E, QualType Ty)
Update the type of a string literal, including any surrounding parentheses, to match the type of the ...
static void updateGNUCompoundLiteralRValue(Expr *E)
Fix a compound literal initializing an array so it's correctly marked as an rvalue.
static bool initializingConstexprVariable(const InitializedEntity &Entity)
static void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity, SourceRange Braces)
Warn that Entity was of scalar type and was initialized by a single-element braced initializer list.
static bool shouldDestroyEntity(const InitializedEntity &Entity)
Whether the given entity, when initialized with an object created for that initialization,...
static SourceLocation getInitializationLoc(const InitializedEntity &Entity, Expr *Initializer)
Get the location at which initialization diagnostics should appear.
static bool hasAnyDesignatedInits(const InitListExpr *IL)
static bool tryObjCWritebackConversion(Sema &S, InitializationSequence &Sequence, const InitializedEntity &Entity, Expr *Initializer)
static DesignatedInitExpr * CloneDesignatedInitExpr(Sema &SemaRef, DesignatedInitExpr *DIE)
static ExprResult CopyObject(Sema &S, QualType T, const InitializedEntity &Entity, ExprResult CurInit, bool IsExtraneousCopy)
Make a (potentially elidable) temporary copy of the object provided by the given initializer by calli...
static Sema::AssignmentAction getAssignmentAction(const InitializedEntity &Entity, bool Diagnose=false)
static void TryOrBuildParenListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr * > Args, InitializationSequence &Sequence, bool VerifyOnly, ExprResult *Result=nullptr)
static void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr, bool IsReturnStmt)
Provide warnings when std::move is used on construction.
static void CheckC23ConstexprInitStringLiteral(const StringLiteral *SE, Sema &SemaRef, QualType &TT)
static void CheckCXX98CompatAccessibleCopy(Sema &S, const InitializedEntity &Entity, Expr *CurInitExpr)
Check whether elidable copy construction for binding a reference to a temporary would have succeeded ...
static bool isOrIsDerivedFromSpecializationOf(CXXRecordDecl *RD, ClassTemplateDecl *CTD)
Determine whether RD is, or is derived from, a specialization of CTD.
static bool canInitializeArrayWithEmbedDataString(ArrayRef< Expr * > ExprList, const InitializedEntity &Entity, ASTContext &Context)
static bool TryInitializerListConstruction(Sema &S, InitListExpr *List, QualType DestType, InitializationSequence &Sequence, bool TreatUnavailableAsInvalid)
When initializing from init list via constructor, handle initialization of an object of type std::ini...
static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT, ASTContext &Context)
Check whether the array of type AT can be initialized by the Init expression by means of string initi...
@ SIF_PlainStringIntoUTF8Char
@ SIF_IncompatWideStringIntoWideChar
@ SIF_UTF8StringIntoPlainChar
@ SIF_NarrowStringIntoWideChar
static void TryDefaultInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitializationSequence &Sequence)
Attempt default initialization (C++ [dcl.init]p6).
static bool TryOCLSamplerInitialization(Sema &S, InitializationSequence &Sequence, QualType DestType, Expr *Initializer)
static bool maybeRecoverWithZeroInitialization(Sema &S, InitializationSequence &Sequence, const InitializedEntity &Entity)
Tries to add a zero initializer. Returns true if that worked.
static ExprResult CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value)
Check that the given Index expression is a valid array designator value.
static bool canPerformArrayCopy(const InitializedEntity &Entity)
Determine whether we can perform an elementwise array copy for this kind of entity.
static bool IsZeroInitializer(Expr *Initializer, Sema &S)
static void TryReferenceInitializationCore(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, QualType cv1T1, QualType T1, Qualifiers T1Quals, QualType cv2T2, QualType T2, Qualifiers T2Quals, InitializationSequence &Sequence, bool TopLevelOfInitList)
Reference initialization without resolving overloaded functions.
static void CheckC23ConstexprInitConversion(Sema &S, QualType FromType, QualType ToType, Expr *Init)
static void ExpandAnonymousFieldDesignator(Sema &SemaRef, DesignatedInitExpr *DIE, unsigned DesigIdx, IndirectFieldDecl *IndirectField)
Expand a field designator that refers to a member of an anonymous struct or union into a series of fi...
static void TryValueInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitializationSequence &Sequence, InitListExpr *InitList=nullptr)
Attempt value initialization (C++ [dcl.init]p7).
static void TryUserDefinedConversion(Sema &S, QualType DestType, const InitializationKind &Kind, Expr *Initializer, InitializationSequence &Sequence, bool TopLevelOfInitList)
Attempt a user-defined conversion between two types (C++ [dcl.init]), which enumerates all conversion...
static OverloadingResult ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc, MultiExprArg Args, OverloadCandidateSet &CandidateSet, QualType DestType, DeclContext::lookup_result Ctors, OverloadCandidateSet::iterator &Best, bool CopyInitializing, bool AllowExplicit, bool OnlyListConstructors, bool IsListInit, bool RequireActualConstructor, bool SecondStepOfCopyInit=false)
static void TryListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitListExpr *InitList, InitializationSequence &Sequence, bool TreatUnavailableAsInvalid)
Attempt list initialization (C++0x [dcl.init.list])
static void TryStringLiteralInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, InitializationSequence &Sequence)
Attempt character array initialization from a string literal (C++ [dcl.init.string],...
static bool checkDestructorReference(QualType ElementType, SourceLocation Loc, Sema &SemaRef)
Check if the type of a class element has an accessible destructor, and marks it referenced.
static void TryReferenceInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, InitializationSequence &Sequence, bool TopLevelOfInitList)
Attempt reference initialization (C++0x [dcl.init.ref])
static void DiagnoseNarrowingInInitList(Sema &S, const ImplicitConversionSequence &ICS, QualType PreNarrowingType, QualType EntityType, const Expr *PostInit)
static bool hasCompatibleArrayTypes(ASTContext &Context, const ArrayType *Dest, const ArrayType *Source)
Determine whether we have compatible array types for the purposes of GNU by-copy array initialization...
static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT, Sema &S, bool CheckC23ConstexprInit=false)
static bool isExplicitTemporary(const InitializedEntity &Entity, const InitializationKind &Kind, unsigned NumArgs)
Returns true if the parameters describe a constructor initialization of an explicit temporary object,...
static bool isNonReferenceableGLValue(Expr *E)
Determine whether an expression is a non-referenceable glvalue (one to which a reference can never bi...
static bool TryOCLZeroOpaqueTypeInitialization(Sema &S, InitializationSequence &Sequence, QualType DestType, Expr *Initializer)
static bool IsWideCharCompatible(QualType T, ASTContext &Context)
Check whether T is compatible with a wide character type (wchar_t, char16_t or char32_t).
static void diagnoseListInit(Sema &S, const InitializedEntity &Entity, InitListExpr *InitList)
static OverloadingResult TryRefInitWithConversionFunction(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, bool AllowRValues, bool IsLValueRef, InitializationSequence &Sequence)
Try a reference initialization that involves calling a conversion function.
static void TryConstructorInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType DestType, QualType DestArrayType, InitializationSequence &Sequence, bool IsListInit=false, bool IsInitListCopy=false)
Attempt initialization by constructor (C++ [dcl.init]), which enumerates the constructors of the init...
static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity, Expr *op)
Emit notes associated with an initialization that failed due to a "simple" conversion failure.
static bool isIdiomaticBraceElisionEntity(const InitializedEntity &Entity)
Determine whether Entity is an entity for which it is idiomatic to elide the braces in aggregate init...
static void MaybeProduceObjCObject(Sema &S, InitializationSequence &Sequence, const InitializedEntity &Entity)
static void checkIndirectCopyRestoreSource(Sema &S, Expr *src)
Check whether the given expression is a valid operand for an indirect copy/restore.
static bool shouldBindAsTemporary(const InitializedEntity &Entity)
Whether we should bind a created object as a temporary when initializing the given entity.
static bool ResolveOverloadedFunctionForReferenceBinding(Sema &S, Expr *Initializer, QualType &SourceType, QualType &UnqualifiedSourceType, QualType UnqualifiedTargetType, InitializationSequence &Sequence)
InvalidICRKind
The non-zero enum values here are indexes into diagnostic alternatives.
static ExprResult PerformConstructorInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, const InitializationSequence::Step &Step, bool &ConstructorInitRequiresZeroInit, bool IsListInitialization, bool IsStdInitListInitialization, SourceLocation LBraceLoc, SourceLocation RBraceLoc)
static void TryReferenceListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitListExpr *InitList, InitializationSequence &Sequence, bool TreatUnavailableAsInvalid)
Attempt list initialization of a reference.
static bool isLibstdcxxPointerReturnFalseHack(Sema &S, const InitializedEntity &Entity, const Expr *Init)
An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>, a function with a pointer...
static bool hasCopyOrMoveCtorParam(ASTContext &Ctx, const ConstructorInfo &Info)
Determine if the constructor has the signature of a copy or move constructor for the type T of the cl...
static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc, QualType T)
Somewhere within T there is an uninitialized reference subobject.
static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e, bool isAddressOf, bool &isWeakAccess)
Determines whether this expression is an acceptable ICR source.
This file declares semantic analysis for Objective-C.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TypeLoc interface and its subclasses.
__device__ __2f16 float __ockl_bool s
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
std::string getAsString(const ASTContext &Ctx, QualType Ty) const
bool isNullPointer() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
const ConstantArrayType * getAsConstantArrayType(QualType T) const
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
unsigned getIntWidth(QualType T) const
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
DeclarationNameTable DeclarationNames
QualType getRecordType(const RecordDecl *Decl) const
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
QualType getPackExpansionType(QualType Pattern, std::optional< unsigned > NumExpansions, bool ExpectPackInType=true)
Form a pack expansion type with the given pattern.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
const VariableArrayType * getAsVariableArrayType(QualType T) const
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
const TargetInfo & getTargetInfo() const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
QualType getWideCharType() const
Return the type of wide characters.
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Represents a loop initializing the elements of an array.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
This class is used for builtin types like 'int'.
Represents a base class of a C++ class.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
QualType getType() const
Retrieves the type of the base class.
Represents a call to a C++ constructor.
Expr * getArg(unsigned Arg)
Return the specified argument.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Represents a C++ constructor within a class.
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isExplicit() const
Return true if the declaration is already resolved to be explicit.
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Represents a C++ conversion function within a class.
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a C++ deduction guide declaration.
Represents a C++ destructor within a class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
static CXXParenListInitExpr * Create(ASTContext &C, ArrayRef< Expr * > Args, QualType T, unsigned NumUserSpecifiedExprs, SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Represents a C++ struct/union/class.
bool hasUninitializedReferenceMember() const
Whether this class or any of its subobjects has any members of reference type which would make value-...
bool allowConstDefaultInit() const
Determine whether declaring a const variable with this type is ok per core issue 253.
CXXRecordDecl * getDefinition() const
llvm::iterator_range< conversion_iterator > getVisibleConversionFunctions() const
Get all conversion functions visible in current class, including conversion function templates.
unsigned getNumBases() const
Retrieves the number of base classes of this class.
llvm::iterator_range< base_class_iterator > base_class_range
llvm::iterator_range< base_class_const_iterator > base_class_const_range
bool forallBases(ForallBasesCallback BaseMatches) const
Determines if the given callback holds for all the direct or indirect base classes of this type.
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type.
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
static CXXTemporaryObjectExpr * Create(const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty, TypeSourceInfo *TSI, ArrayRef< Expr * > Args, SourceRange ParenOrBraceRange, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization)
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
SourceLocation getBeginLoc() const LLVM_READONLY
bool isCallToStdMove() const
SourceLocation getRParenLoc() const
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
SourceLocation getBegin() const
Declaration of a class template.
void setExprNeedsCleanups(bool SideEffects)
Complex values, per C99 6.2.5p11.
QualType getElementType() const
ConditionalOperator - The ?: ternary operator.
Represents the canonical version of C arrays with a specified constant size.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
virtual bool ValidateCandidate(const TypoCorrection &candidate)
Simple predicate used by the default RankCandidate to determine whether to return an edit distance of...
virtual std::unique_ptr< CorrectionCandidateCallback > clone()=0
Clone this CorrectionCandidateCallback.
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
NamedDecl * getDecl() const
The results of name lookup within a DeclContext.
decl_iterator - Iterates through the declarations stored within this context.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
A reference to a declared variable, function, enum, etc.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Decl - This represents one declaration (or definition), e.g.
SourceLocation getEndLoc() const LLVM_READONLY
bool isInvalidDecl() const
SourceLocation getLocation() const
DeclContext * getDeclContext()
SourceLocation getBeginLoc() const LLVM_READONLY
The name of a declaration.
SourceLocation getBeginLoc() const LLVM_READONLY
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Represents a single C99 designator.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getFieldLoc() const
SourceLocation getDotLoc() const
Represents a C99 designated initializer expression.
bool isDirectInit() const
Whether this designated initializer should result in direct-initialization of the designated subobjec...
Expr * getArrayRangeEnd(const Designator &D) const
Expr * getSubExpr(unsigned Idx) const
llvm::MutableArrayRef< Designator > designators()
bool usesGNUSyntax() const
Determines whether this designated initializer used the deprecated GNU syntax for designated initiali...
Expr * getArrayRangeStart(const Designator &D) const
void ExpandDesignator(const ASTContext &C, unsigned Idx, const Designator *First, const Designator *Last)
Replaces the designator at index Idx with the series of designators in [First, Last).
static DesignatedInitExpr * Create(const ASTContext &C, llvm::ArrayRef< Designator > Designators, ArrayRef< Expr * > IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)
Expr * getArrayIndex(const Designator &D) const
Designator * getDesignator(unsigned Idx)
Expr * getInit() const
Retrieve the initializer value.
unsigned size() const
Returns the number of designators in this initializer.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getEqualOrColonLoc() const
Retrieve the location of the '=' that precedes the initializer value itself, if present.
unsigned getNumSubExprs() const
Retrieve the total number of subexpressions in this designated initializer expression,...
InitListExpr * getUpdater() const
Designation - Represent a full designation, which is a sequence of designators.
const Designator & getDesignator(unsigned Idx) const
unsigned getNumDesignators() const
Designator - A designator in a C99 designated initializer.
static Designator CreateFieldDesignator(const IdentifierInfo *FieldName, SourceLocation DotLoc, SourceLocation FieldLoc)
Creates a field designator.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Represents a reference to #emded data.
StringLiteral * getDataStringLiteral() const
EmbedDataStorage * getData() const
SourceLocation getLocation() const
size_t getDataElementCount() const
RAII object that enters a new expression evaluation context.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
The return type of classify().
This represents one expression.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool refersToVectorElement() const
Returns whether this expression refers to a vector element.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
@ NPC_ValueDependentIsNotNull
Specifies that a value-dependent expression should be considered to never be a null pointer constant.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type.
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
bool refersToMatrixElement() const
Returns whether this expression refers to a matrix element.
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
ExtVectorType - Extended vector type.
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isUnnamedBitField() const
Determines whether this is an unnamed bitfield.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Represents a function declaration or definition.
const ParmVarDecl * getParamDecl(unsigned i) const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
QualType getReturnType() const
bool isDeleted() const
Whether this function has been deleted.
bool isDefaulted() const
Whether this function is defaulted.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
One of these records is kept for each identifier that is lexed.
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
@ StaticObjectArgumentConversion
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence.
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
static ImplicitConversionSequence getNullptrToBool(QualType SourceType, QualType DestType, bool NeedLValToRVal)
Form an "implicit" conversion sequence from nullptr_t to bool, for a direct-initialization of a bool ...
Represents an implicitly-generated value initialization of an object of a given type.
Represents a C array with an unspecified size.
Represents a field injected from an anonymous union/struct into the parent scope.
chain_iterator chain_end() const
chain_iterator chain_begin() const
ArrayRef< NamedDecl * >::const_iterator chain_iterator
Describes an C or C++ initializer list.
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
void setSyntacticForm(InitListExpr *Init)
void markError()
Mark the semantic form of the InitListExpr as error when the semantic analysis fails.
bool hasDesignatedInit() const
Determine whether this initializer list contains a designated initializer.
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic,...
void resizeInits(const ASTContext &Context, unsigned NumInits)
Specify the number of initializers.
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
unsigned getNumInits() const
SourceLocation getBeginLoc() const LLVM_READONLY
void setInit(unsigned Init, Expr *expr)
SourceLocation getLBraceLoc() const
Expr * updateInit(const ASTContext &C, unsigned Init, Expr *expr)
Updates the initializer at index Init with the new expression expr, and returns the old expression at...
void setArrayFiller(Expr *filler)
InitListExpr * getSyntacticForm() const
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
SourceLocation getRBraceLoc() const
const Expr * getInit(unsigned Init) const
bool isIdiomaticZeroInitializer(const LangOptions &LangOpts) const
Is this the zero initializer {0} in a language which considers it idiomatic?
SourceLocation getEndLoc() const LLVM_READONLY
void setInitializedFieldInUnion(FieldDecl *FD)
bool isSyntacticForm() const
ArrayRef< Expr * > inits()
void setRBraceLoc(SourceLocation Loc)
void sawArrayRangeDesignator(bool ARD=true)
Expr ** getInits()
Retrieve the set of initializers.
Describes the kind of initialization being performed, along with location information for tokens rela...
@ IK_DirectList
Direct list-initialization.
@ IK_Value
Value initialization.
@ IK_Direct
Direct initialization.
@ IK_Copy
Copy initialization.
@ IK_Default
Default initialization.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static InitializationKind CreateDirectList(SourceLocation InitLoc)
static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool isImplicit=false)
Create a value initialization.
A single step in the initialization sequence.
StepKind Kind
The kind of conversion or initialization step we are taking.
InitListExpr * WrappingSyntacticList
When Kind = SK_RewrapInitList, the syntactic form of the wrapping list.
ImplicitConversionSequence * ICS
When Kind = SK_ConversionSequence, the implicit conversion sequence.
struct F Function
When Kind == SK_ResolvedOverloadedFunction or Kind == SK_UserConversion, the function that the expres...
Describes the sequence of initializations required to initialize a given object or reference with a s...
step_iterator step_begin() const
void AddListInitializationStep(QualType T)
Add a list-initialization step.
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
void AddStringInitStep(QualType T)
Add a string init step.
void AddStdInitializerListConstructionStep(QualType T)
Add a step to construct a std::initializer_list object from an initializer list.
void AddConstructorInitializationStep(DeclAccessPair FoundDecl, CXXConstructorDecl *Constructor, QualType T, bool HadMultipleCandidates, bool FromInitList, bool AsInitList)
Add a constructor-initialization step.
@ SK_StdInitializerListConstructorCall
Perform initialization via a constructor taking a single std::initializer_list argument.
@ SK_AtomicConversion
Perform a conversion adding _Atomic to a type.
@ SK_ObjCObjectConversion
An initialization that "converts" an Objective-C object (not a point to an object) to another Objecti...
@ SK_GNUArrayInit
Array initialization (from an array rvalue) as a GNU extension.
@ SK_CastDerivedToBaseLValue
Perform a derived-to-base cast, producing an lvalue.
@ SK_ProduceObjCObject
Produce an Objective-C object pointer.
@ SK_FunctionReferenceConversion
Perform a function reference conversion, see [dcl.init.ref]p4.
@ SK_BindReference
Reference binding to an lvalue.
@ SK_ArrayLoopInit
Array initialization by elementwise copy.
@ SK_ConstructorInitialization
Perform initialization via a constructor.
@ SK_OCLSamplerInit
Initialize an OpenCL sampler from an integer.
@ SK_StringInit
Initialization by string.
@ SK_ZeroInitialization
Zero-initialize the object.
@ SK_CastDerivedToBaseXValue
Perform a derived-to-base cast, producing an xvalue.
@ SK_QualificationConversionXValue
Perform a qualification conversion, producing an xvalue.
@ SK_UserConversion
Perform a user-defined conversion, either via a conversion function or via a constructor.
@ SK_CastDerivedToBasePRValue
Perform a derived-to-base cast, producing an rvalue.
@ SK_BindReferenceToTemporary
Reference binding to a temporary.
@ SK_PassByIndirectRestore
Pass an object by indirect restore.
@ SK_ParenthesizedArrayInit
Array initialization from a parenthesized initializer list.
@ SK_ParenthesizedListInit
Initialize an aggreagate with parenthesized list of values.
@ SK_ArrayInit
Array initialization (from an array rvalue).
@ SK_ExtraneousCopyToTemporary
An optional copy of a temporary object to another temporary object, which is permitted (but not requi...
@ SK_ArrayLoopIndex
Array indexing for initialization by elementwise copy.
@ SK_ConversionSequenceNoNarrowing
Perform an implicit conversion sequence without narrowing.
@ SK_RewrapInitList
Rewrap the single-element initializer list for a reference.
@ SK_CAssignment
C assignment.
@ SK_ConstructorInitializationFromList
Perform initialization via a constructor, taking arguments from a single InitListExpr.
@ SK_PassByIndirectCopyRestore
Pass an object by indirect copy-and-restore.
@ SK_ResolveAddressOfOverloadedFunction
Resolve the address of an overloaded function to a specific function declaration.
@ SK_UnwrapInitList
Unwrap the single-element initializer list for a reference.
@ SK_FinalCopy
Direct-initialization from a reference-related object in the final stage of class copy-initialization...
@ SK_QualificationConversionLValue
Perform a qualification conversion, producing an lvalue.
@ SK_StdInitializerList
Construct a std::initializer_list from an initializer list.
@ SK_QualificationConversionPRValue
Perform a qualification conversion, producing a prvalue.
@ SK_ConversionSequence
Perform an implicit conversion sequence.
@ SK_ListInitialization
Perform list-initialization without a constructor.
@ SK_OCLZeroOpaqueType
Initialize an opaque OpenCL type (event_t, queue_t, etc.) with zero.
void AddUserConversionStep(FunctionDecl *Function, DeclAccessPair FoundDecl, QualType T, bool HadMultipleCandidates)
Add a new step invoking a conversion function, which is either a constructor or a conversion function...
void SetZeroInitializationFixit(const std::string &Fixit, SourceLocation L)
Call for initializations are invalid but that would be valid zero initialzations if Fixit was applied...
InitializationSequence(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, bool TopLevelOfInitList=false, bool TreatUnavailableAsInvalid=true)
Try to perform initialization of the given entity, creating a record of the steps required to perform...
void AddQualificationConversionStep(QualType Ty, ExprValueKind Category)
Add a new step that performs a qualification conversion to the given type.
void AddFunctionReferenceConversionStep(QualType Ty)
Add a new step that performs a function reference conversion to the given type.
~InitializationSequence()
void AddDerivedToBaseCastStep(QualType BaseType, ExprValueKind Category)
Add a new step in the initialization that performs a derived-to- base cast.
FailureKind getFailureKind() const
Determine why initialization failed.
void InitializeFrom(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, bool TopLevelOfInitList, bool TreatUnavailableAsInvalid)
void AddParenthesizedListInitStep(QualType T)
void SetFailed(FailureKind Failure)
Note that this initialization sequence failed.
bool isAmbiguous() const
Determine whether this initialization failed due to an ambiguity.
void AddOCLZeroOpaqueTypeStep(QualType T)
Add a step to initialzie an OpenCL opaque type (event_t, queue_t, etc.) from a zero constant.
void AddFinalCopy(QualType T)
Add a new step that makes a copy of the input to an object of the given type, as the final step in cl...
void setSequenceKind(enum SequenceKind SK)
Set the kind of sequence computed.
void AddObjCObjectConversionStep(QualType T)
Add an Objective-C object conversion step, which is always a no-op.
void SetOverloadFailure(FailureKind Failure, OverloadingResult Result)
Note that this initialization sequence failed due to failed overload resolution.
step_iterator step_end() const
void AddParenthesizedArrayInitStep(QualType T)
Add a parenthesized array initialization step.
void AddExtraneousCopyToTemporary(QualType T)
Add a new step that makes an extraneous copy of the input to a temporary of the same class type.
void setIncompleteTypeFailure(QualType IncompleteType)
Note that this initialization sequence failed due to an incomplete type.
void AddOCLSamplerInitStep(QualType T)
Add a step to initialize an OpenCL sampler from an integer constant.
void AddCAssignmentStep(QualType T)
Add a C assignment step.
void AddPassByIndirectCopyRestoreStep(QualType T, bool shouldCopy)
Add a step to pass an object by indirect copy-restore.
void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic)
Add steps to unwrap a initializer list for a reference around a single element and rewrap it at the e...
bool Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr * > Args)
Diagnose an potentially-invalid initialization sequence.
bool Failed() const
Determine whether the initialization sequence is invalid.
void AddAtomicConversionStep(QualType Ty)
Add a new step that performs conversion from non-atomic to atomic type.
void dump() const
Dump a representation of this initialization sequence to standard error, for debugging purposes.
void AddConversionSequenceStep(const ImplicitConversionSequence &ICS, QualType T, bool TopLevelOfInitList=false)
Add a new step that applies an implicit conversion sequence.
void AddZeroInitializationStep(QualType T)
Add a zero-initialization step.
void AddProduceObjCObjectStep(QualType T)
Add a step to "produce" an Objective-C object (by retaining it).
enum SequenceKind getKind() const
Determine the kind of initialization sequence computed.
SequenceKind
Describes the kind of initialization sequence computed.
@ NormalSequence
A normal sequence.
@ FailedSequence
A failed initialization sequence.
@ DependentSequence
A dependent initialization, which could not be type-checked due to the presence of dependent types or...
void AddReferenceBindingStep(QualType T, bool BindingTemporary)
Add a new step binding a reference to an object.
FailureKind
Describes why initialization failed.
@ FK_UserConversionOverloadFailed
Overloading for a user-defined conversion failed.
@ FK_NarrowStringIntoWideCharArray
Initializing a wide char array with narrow string literal.
@ FK_ArrayTypeMismatch
Array type mismatch.
@ FK_ParenthesizedListInitForReference
Reference initialized from a parenthesized initializer list.
@ FK_NonConstLValueReferenceBindingToVectorElement
Non-const lvalue reference binding to a vector element.
@ FK_ReferenceInitDropsQualifiers
Reference binding drops qualifiers.
@ FK_InitListBadDestinationType
Initialization of some unused destination type with an initializer list.
@ FK_ConversionFromPropertyFailed
Implicit conversion failed.
@ FK_NonConstLValueReferenceBindingToUnrelated
Non-const lvalue reference binding to an lvalue of unrelated type.
@ FK_ListConstructorOverloadFailed
Overloading for list-initialization by constructor failed.
@ FK_ReferenceInitFailed
Reference binding failed.
@ FK_DesignatedInitForNonAggregate
@ FK_ArrayNeedsInitList
Array must be initialized with an initializer list.
@ FK_PlainStringIntoUTF8Char
Initializing char8_t array with plain string literal.
@ FK_NonConstantArrayInit
Non-constant array initializer.
@ FK_NonConstLValueReferenceBindingToTemporary
Non-const lvalue reference binding to a temporary.
@ FK_ConversionFailed
Implicit conversion failed.
@ FK_ArrayNeedsInitListOrStringLiteral
Array must be initialized with an initializer list or a string literal.
@ FK_ParenthesizedListInitForScalar
Scalar initialized from a parenthesized initializer list.
@ FK_PlaceholderType
Initializer has a placeholder type which cannot be resolved by initialization.
@ FK_IncompatWideStringIntoWideChar
Initializing wide char array with incompatible wide string literal.
@ FK_NonConstLValueReferenceBindingToMatrixElement
Non-const lvalue reference binding to a matrix element.
@ FK_TooManyInitsForReference
Too many initializers provided for a reference.
@ FK_NonConstLValueReferenceBindingToBitfield
Non-const lvalue reference binding to a bit-field.
@ FK_ReferenceAddrspaceMismatchTemporary
Reference with mismatching address space binding to temporary.
@ FK_ListInitializationFailed
List initialization failed at some point.
@ FK_TooManyInitsForScalar
Too many initializers for scalar.
@ FK_AddressOfOverloadFailed
Cannot resolve the address of an overloaded function.
@ FK_VariableLengthArrayHasInitializer
Variable-length array must not have an initializer.
@ FK_ArrayNeedsInitListOrWideStringLiteral
Array must be initialized with an initializer list or a wide string literal.
@ FK_RValueReferenceBindingToLValue
Rvalue reference binding to an lvalue.
@ FK_Incomplete
Initialization of an incomplete type.
@ FK_WideStringIntoCharArray
Initializing char array with wide string literal.
@ FK_ExplicitConstructor
List-copy-initialization chose an explicit constructor.
@ FK_ReferenceInitOverloadFailed
Overloading due to reference initialization failed.
@ FK_ConstructorOverloadFailed
Overloading for initialization by constructor failed.
@ FK_ReferenceBindingToInitList
Reference initialization from an initializer list.
@ FK_DefaultInitOfConst
Default-initialization of a 'const' object.
@ FK_ParenthesizedListInitFailed
Parenthesized list initialization failed at some point.
@ FK_AddressOfUnaddressableFunction
Trying to take the address of a function that doesn't support having its address taken.
@ FK_UTF8StringIntoPlainChar
Initializing char array with UTF-8 string literal.
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init....
void AddArrayInitLoopStep(QualType T, QualType EltTy)
Add an array initialization loop step.
void AddAddressOverloadResolutionStep(FunctionDecl *Function, DeclAccessPair Found, bool HadMultipleCandidates)
Add a new step in the initialization that resolves the address of an overloaded function to a specifi...
void AddArrayInitStep(QualType T, bool IsGNUExtension)
Add an array initialization step.
bool isConstructorInitialization() const
Determine whether this initialization is direct call to a constructor.
SmallVectorImpl< Step >::const_iterator step_iterator
OverloadCandidateSet & getFailedCandidateSet()
Retrieve a reference to the candidate set when overload resolution fails.
Describes an entity that is being initialized.
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a base class subobject.
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
VD Variable
When Kind == EK_Variable, EK_Member, EK_Binding, or EK_TemplateParameter, the variable,...
EntityKind getKind() const
Determine the kind of initialization.
DeclarationName getName() const
Retrieve the name of the entity being initialized.
QualType getType() const
Retrieve type being initialized.
ValueDecl * getDecl() const
Retrieve the variable, parameter, or field being initialized.
bool isImplicitMemberInitializer() const
Is this the implicit initialization of a member of a class from a defaulted constructor?
const InitializedEntity * getParent() const
Retrieve the parent of the entity being initialized, when the initialization itself is occurring with...
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
bool isParameterConsumed() const
Determine whether this initialization consumes the parameter.
static InitializedEntity InitializeElement(ASTContext &Context, unsigned Index, const InitializedEntity &Parent)
Create the initialization entity for an array element.
unsigned getElementIndex() const
If this is an array, vector, or complex number element, get the element's index.
void setElementIndex(unsigned Index)
If this is already the initializer for an array or vector element, sets the element index.
SourceLocation getCaptureLoc() const
Determine the location of the capture when initializing field from a captured variable in a lambda.
bool isParamOrTemplateParamKind() const
llvm::PointerIntPair< const CXXBaseSpecifier *, 1 > Base
When Kind == EK_Base, the base specifier that provides the base class.
bool allowsNRVO() const
Determine whether this initialization allows the named return value optimization, which also applies ...
bool isParameterKind() const
void dump() const
Dump a representation of the initialized entity to standard error, for debugging purposes.
EntityKind
Specifies the kind of entity being initialized.
@ EK_Variable
The entity being initialized is a variable.
@ EK_Temporary
The entity being initialized is a temporary object.
@ EK_Binding
The entity being initialized is a structured binding of a decomposition declaration.
@ EK_BlockElement
The entity being initialized is a field of block descriptor for the copied-in c++ object.
@ EK_Parameter_CF_Audited
The entity being initialized is a function parameter; function is member of group of audited CF APIs.
@ EK_LambdaToBlockConversionBlockElement
The entity being initialized is a field of block descriptor for the copied-in lambda object that's us...
@ EK_Member
The entity being initialized is a non-static data member subobject.
@ EK_Base
The entity being initialized is a base member subobject.
@ EK_Result
The entity being initialized is the result of a function call.
@ EK_TemplateParameter
The entity being initialized is a non-type template parameter.
@ EK_StmtExprResult
The entity being initialized is the result of a statement expression.
@ EK_ParenAggInitMember
The entity being initialized is a non-static data member subobject of an object initialized via paren...
@ EK_VectorElement
The entity being initialized is an element of a vector.
@ EK_New
The entity being initialized is an object (or array of objects) allocated via new.
@ EK_CompoundLiteralInit
The entity being initialized is the initializer for a compound literal.
@ EK_Parameter
The entity being initialized is a function parameter.
@ EK_Delegating
The initialization is being done by a delegating constructor.
@ EK_ComplexElement
The entity being initialized is the real or imaginary part of a complex number.
@ EK_ArrayElement
The entity being initialized is an element of an array.
@ EK_LambdaCapture
The entity being initialized is the field that captures a variable in a lambda.
@ EK_Exception
The entity being initialized is an exception object that is being thrown.
@ EK_RelatedResult
The entity being implicitly initialized back to the formal result type.
static InitializedEntity InitializeMemberFromParenAggInit(FieldDecl *Member)
Create the initialization entity for a member subobject initialized via parenthesized aggregate init.
SourceLocation getThrowLoc() const
Determine the location of the 'throw' keyword when initializing an exception object.
unsigned Index
When Kind == EK_ArrayElement, EK_VectorElement, or EK_ComplexElement, the index of the array or vecto...
bool isVariableLengthArrayNew() const
Determine whether this is an array new with an unknown bound.
llvm::PointerIntPair< ParmVarDecl *, 1 > Parameter
When Kind == EK_Parameter, the ParmVarDecl, with the integer indicating whether the parameter is "con...
const CXXBaseSpecifier * getBaseSpecifier() const
Retrieve the base specifier.
SourceLocation getReturnLoc() const
Determine the location of the 'return' keyword when initializing the result of a function call.
TypeSourceInfo * getTypeSourceInfo() const
Retrieve complete type-source information for the object being constructed, if known.
ObjCMethodDecl * getMethodDecl() const
Retrieve the ObjectiveC method being initialized.
The injected class name of a C++ class template or class template partial specialization.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
An lvalue reference type, per C++11 [dcl.ref].
Represents the results of name lookup.
bool empty() const
Return true if no decls were found.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
This represents a decl that may have a name.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represent a C++ namespace.
Represents a place-holder for an object not to be initialized by anything.
ObjCEncodeExpr, used for @encode in Objective-C.
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
bool isAvailableOption(llvm::StringRef Ext, const LangOptions &LO) const
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
void clear(CandidateSetKind CSK)
Clear out all of the candidates.
void setDestAS(LangAS AS)
@ CSK_InitByConstructor
C++ [over.match.ctor], [over.match.list] Initialization of an object of class type by constructor,...
@ CSK_InitByUserDefinedConversion
C++ [over.match.copy]: Copy-initialization of an object of class type by user-defined conversion.
@ CSK_Normal
Normal lookup.
SmallVectorImpl< OverloadCandidate >::iterator iterator
void NoteCandidates(PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
SmallVector< OverloadCandidate *, 32 > CompleteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, SourceLocation OpLoc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
Represents a parameter to a function.
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
QualType withConst() const
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool isConstQualified() const
Determine whether this type is const-qualified.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
The collection of all-type qualifiers we support.
unsigned getCVRQualifiers() const
void addAddressSpace(LangAS space)
@ OCL_Weak
Reading or writing from this object requires a barrier call.
bool hasQualifiers() const
Return true if the set contains any qualifiers.
bool hasAddressSpace() const
Qualifiers withoutAddressSpace() const
void removeAddressSpace()
static Qualifiers fromCVRMask(unsigned CVR)
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B)
Returns true if address space A is equal to or a superset of B.
bool hasObjCLifetime() const
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
LangAS getAddressSpace() const
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
bool hasFlexibleArrayMember() const
field_iterator field_end() const
field_range fields() const
bool isRandomized() const
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
specific_decl_iterator< FieldDecl > field_iterator
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Base for LValueReferenceType and RValueReferenceType.
bool isSpelledAsLValue() const
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
bool CheckObjCBridgeRelatedConversions(SourceLocation Loc, QualType DestType, QualType SrcType, Expr *&SrcExpr, bool Diagnose=true)
bool isObjCWritebackConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
Determine whether this is an Objective-C writeback conversion, used for parameter passing when perfor...
bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr, bool Diagnose=true)
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type,...
void EmitRelatedResultTypeNoteForReturn(QualType destType)
Given that we had incompatible pointer types in a return statement, check whether we're in a method w...
Sema - This implements semantic analysis and AST building for C.
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
CXXSpecialMemberKind getSpecialMember(const CXXMethodDecl *MD)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
bool DiagRedefinedPlaceholderFieldDecl(SourceLocation Loc, RecordDecl *ClassDecl, const IdentifierInfo *Name)
ImplicitConversionSequence TryImplicitConversion(Expr *From, QualType ToType, bool SuppressUserConversions, AllowedExplicit AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion)
bool IsStringInit(Expr *Init, const ArrayType *AT)
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, QualType DeclInitType, MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl< Expr * > &ConvertedArgs, bool AllowExplicit=false, bool IsListInitialization=false)
Given a constructor and the set of arguments provided for the constructor, convert the arguments and ...
void AddConversionCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion=true)
AddConversionCandidate - Add a C++ conversion function as a candidate in the candidate set (C++ [over...
ReferenceCompareResult
ReferenceCompareResult - Expresses the result of comparing two types (cv1 T1 and cv2 T2) to determine...
@ Ref_Incompatible
Ref_Incompatible - The two types are incompatible, so direct reference binding is not possible.
@ Ref_Compatible
Ref_Compatible - The two types are reference-compatible.
@ Ref_Related
Ref_Related - The two types are reference-related, which means that their unqualified forms (T1 and T...
void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion=true)
Adds a conversion function template specialization candidate to the overload set, using template argu...
FunctionTemplateDecl * DeclareAggregateDeductionGuideFromInitList(TemplateDecl *Template, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc)
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor,...
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
ExprResult ActOnDesignatedInitializer(Designation &Desig, SourceLocation EqualOrColonLoc, bool GNUSyntax, ExprResult Init)
FPOptionsOverride CurFPFeatureOverrides()
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we're implicitly casting from a _Nullable pointer type to a _Nonnull one.
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over....
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
ASTContext & getASTContext() const
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
bool isInitListConstructor(const FunctionDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init....
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, const SourceRange &, DeclAccessPair FoundDecl)
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
llvm::SmallVector< QualType, 4 > CurrentParameterCopyTypes
Stack of types that correspond to the parameter entities that are currently being copy-initialized.
std::string getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const
Get a string to suggest for zero-initialization of a type.
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
CXXConstructorDecl * LookupDefaultConstructor(CXXRecordDecl *Class)
Look up the default constructor for the given class.
const LangOptions & getLangOpts() const
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
ExprResult PerformQualificationConversion(Expr *E, QualType Ty, ExprValueKind VK=VK_PRValue, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl)
Wrap the expression in a ConstantExpr if it is a potential immediate invocation.
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitDefaultConstructor - Checks for feasibility of defining this constructor as the default...
SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL, unsigned ByteNo) const
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
bool isInLifetimeExtendingContext() const
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, DeclAccessPair FoundDecl, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp=false)
Checks access to a constructor.
AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair FoundDecl)
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ Compatible
Compatible - the types are compatible according to the standard.
@ Incompatible
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, CXXConstructionKind ConstructKind, SourceRange ParenRange)
BuildCXXConstructExpr - Creates a complete call to a constructor, including handling of its default a...
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
ExprResult FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
void DiscardMisalignedMemberAddress(const Type *T, Expr *E)
This function checks if the expression is in the sef of potentially misaligned members and it is conv...
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed.
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=std::nullopt, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
bool CanPerformAggregateInitializationForOverloadResolution(const InitializedEntity &Entity, InitListExpr *From)
Determine whether we can perform aggregate initialization for the purposes of overload resolution.
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL,...
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, ReferenceConversions *Conv=nullptr)
CompareReferenceRelationship - Compare the two types T1 and T2 to determine whether they are referenc...
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the initializer (and its subobjects) is sufficient for initializing the en...
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
QualType getCompletedType(Expr *E)
Get the type of expression E, triggering instantiation to complete the type if necessary – that is,...
SourceManager & SourceMgr
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
NamespaceDecl * getStdNamespace() const
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
QualType SubstAutoTypeDependent(QualType TypeWithAuto)
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
bool CanPerformCopyInitialization(const InitializedEntity &Entity, ExprResult Init)
bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types.
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
CXXConstructorDecl * findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor, ConstructorUsingShadowDecl *DerivedShadow)
Given a derived-class using shadow declaration for a constructor and the correspnding base class cons...
ValueDecl * tryLookupUnambiguousFieldDecl(RecordDecl *ClassDecl, const IdentifierInfo *MemberOrBase)
Encodes a location in the source.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
bool isAtStartOfImmediateMacroExpansion(SourceLocation Loc, SourceLocation *MacroBegin=nullptr) const
Returns true if the given MacroID location points at the beginning of the immediate macro expansion.
A trivial tuple used to represent a source range.
void setBegin(SourceLocation b)
SourceLocation getEnd() const
SourceLocation getBegin() const
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3....
void setFromType(QualType T)
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion,...
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion,...
void setAsIdentityConversion()
StandardConversionSequence - Set the standard conversion sequence to the identity conversion.
void setToType(unsigned Idx, QualType T)
NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted, APValue &ConstantValue, QualType &ConstantType, bool IgnoreFloatToIntegralConversion=false) const
Check if this standard conversion sequence represents a narrowing conversion, according to C++11 [dcl...
void setAllToTypes(QualType T)
QualType getToType(unsigned Idx) const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
unsigned getLength() const
StringLiteralKind getKind() const
int64_t getCodeUnitS(size_t I, uint64_t BitWidth) const
StringRef getString() const
The base class of all kinds of template declarations (e.g., class, function, etc.).
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
bool isDependent() const
Determines whether this is a dependent template name.
Represents a type template specialization; the template must be a class template, a type alias templa...
Base wrapper for a particular "section" of type source info.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceLocation getEndLoc() const
Get the end source location.
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBooleanType() const
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
bool isIncompleteArrayType() const
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isRValueReferenceType() const
bool isConstantArrayType() const
bool isPointerType() const
bool isArrayParameterType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isScalarType() const
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to.
bool isSizelessBuiltinType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isExtVectorType() const
bool isOCLIntelSubgroupAVCType() const
bool isLValueReferenceType() const
bool isOpenCLSpecificType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
bool isAnyComplexType() const
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isAtomicType() const
bool isFunctionProtoType() const
bool isObjCObjectType() const
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isVectorType() const
bool isFloatingType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isNullPtrType() const
bool isRecordType() const
bool isObjCRetainableType() const
Simple class containing the result of Sema::CorrectTypo.
DeclClass * getCorrectionDeclAs() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
const Expr * getInit() const
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Represents a C array with a specified size that is not an integer-constant-expression.
Represents a GCC generic vector type.
unsigned getNumElements() const
VectorKind getVectorKind() const
QualType getElementType() const
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
bool Zero(InterpState &S, CodePtr OpPC)
void checkExprLifetime(Sema &SemaRef, const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the given expr (and its subobjects) is sufficient for initializing the ent...
The JSON file list parser is used to communicate input to InstallAPI.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
OverloadingResult
OverloadingResult - Capture the result of performing overload resolution.
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
@ OR_Ambiguous
Ambiguous candidates found.
@ OR_No_Viable_Function
No viable function found.
@ ovl_fail_bad_conversion
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
@ SD_Automatic
Automatic storage duration (most local variables).
@ Result
The result type of a method or function.
@ ICK_Integral_Conversion
Integral conversions (C++ [conv.integral])
@ ICK_Floating_Integral
Floating-integral conversions (C++ [conv.fpint])
@ ICK_Array_To_Pointer
Array-to-pointer conversion (C++ [conv.array])
@ ICK_Lvalue_To_Rvalue
Lvalue-to-rvalue conversion (C++ [conv.lval])
@ ICK_Writeback_Conversion
Objective-C ARC writeback conversion.
ActionResult< Expr * > ExprResult
CastKind
CastKind - The kind of operation required for a conversion.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
Expr * IgnoreParensSingleStep(Expr *E)
const FunctionProtoType * T
@ NK_Not_Narrowing
Not a narrowing conversion.
@ NK_Constant_Narrowing
A narrowing conversion, because a constant expression got narrowed.
@ NK_Dependent_Narrowing
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
@ NK_Type_Narrowing
A narrowing conversion by virtue of the source and destination types.
@ NK_Variable_Narrowing
A narrowing conversion, because a non-constant-expression variable might have got narrowed.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
ConstructorInfo getConstructorInfo(NamedDecl *ND)
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Braces
New-expression has a C++11 list-initializer.
CheckedConversionKind
The kind of conversion being performed.
@ Implicit
An implicit conversion.
@ CStyleCast
A C-style cast.
@ OtherCast
A cast other than a C-style cast.
@ FunctionalCast
A functional-style cast.
MutableArrayRef< Expr * > MultiExprArg
CXXConstructorDecl * Constructor
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
bool HadMultipleCandidates
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
bool Viable
Viable - True to indicate that this overload candidate is viable.
unsigned char FailureKind
FailureKind - The reason why this candidate is not viable.
ConversionSequenceList Conversions
The conversion sequences used to convert the function arguments to the function parameters.
ReferenceConversions
The conversions that would be performed on an lvalue of type T2 when binding a reference of type T1 t...
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion.