31#include "llvm/ADT/APInt.h"
32#include "llvm/ADT/FoldingSet.h"
33#include "llvm/ADT/PointerIntPair.h"
34#include "llvm/ADT/STLForwardCompat.h"
35#include "llvm/ADT/SmallString.h"
36#include "llvm/ADT/SmallVector.h"
37#include "llvm/ADT/StringExtras.h"
38#include "llvm/Support/ErrorHandling.h"
39#include "llvm/Support/raw_ostream.h"
75 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
93 auto IsCharOrUnsignedChar = [](
const QualType &
T) {
94 const BuiltinType *BT = dyn_cast<BuiltinType>(
T.getTypePtr());
99 case StringLiteralKind::UTF8:
109 case StringLiteralKind::Ordinary:
113 return (SL->
getKind() == StringLiteralKind::UTF8 &&
127 case StringLiteralKind::UTF16:
135 case StringLiteralKind::UTF32:
143 case StringLiteralKind::Wide:
151 case StringLiteralKind::Unevaluated:
152 assert(
false &&
"Unevaluated string literal in initialization");
156 llvm_unreachable(
"missed a StringLiteral kind?");
177 if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
188 if (isa<CompoundLiteralExpr>(E))
203 if (
const auto *VD = dyn_cast_if_present<VarDecl>(D); VD && VD->isConstexpr())
213 Sema &S,
bool CheckC23ConstexprInit =
false) {
215 auto *ConstantArrayTy =
217 uint64_t StrLength = ConstantArrayTy->getZExtSize();
219 if (CheckC23ConstexprInit)
226 llvm::APInt ConstVal(32, StrLength);
252 diag::err_initializer_string_for_char_array_too_long)
258 diag::ext_initializer_string_for_char_array_too_long)
306class InitListChecker {
308 bool hadError =
false;
310 bool TreatUnavailableAsInvalid;
311 bool InOverloadResolution;
325 unsigned &StructuredIndex);
329 bool TopLevelObject =
false);
332 bool SubobjectIsDesignatorContext,
335 unsigned &StructuredIndex,
336 bool TopLevelObject =
false);
341 unsigned &StructuredIndex,
342 bool DirectlyDesignated =
false);
347 unsigned &StructuredIndex);
352 unsigned &StructuredIndex);
357 unsigned &StructuredIndex);
361 unsigned &StructuredIndex);
366 bool SubobjectIsDesignatorContext,
unsigned &Index,
368 unsigned &StructuredIndex,
369 bool TopLevelObject =
false);
372 llvm::APSInt elementIndex,
373 bool SubobjectIsDesignatorContext,
unsigned &Index,
375 unsigned &StructuredIndex);
381 llvm::APSInt *NextElementIndex,
384 unsigned &StructuredIndex,
385 bool FinishSubobjectInit,
386 bool TopLevelObject);
390 unsigned StructuredIndex,
392 bool IsFullyOverwritten =
false);
393 void UpdateStructuredListElement(
InitListExpr *StructuredList,
394 unsigned &StructuredIndex,
398 unsigned ExpectedNumInits);
399 int numArrayElements(
QualType DeclType);
400 int numStructUnionElements(
QualType DeclType);
408 bool UnionOverride =
false,
409 bool FullyOverwritten =
true) {
414 ? (UnionOverride ? diag::ext_initializer_union_overrides
415 : diag::ext_initializer_overrides)
416 : diag::warn_initializer_overrides;
418 if (InOverloadResolution && SemaRef.
getLangOpts().CPlusPlus) {
439 DiagID = diag::err_initializer_overrides_destructed;
459 << NewInitRange << FullyOverwritten << OldInit->
getType();
488 bool FillWithNoInit);
489 void FillInEmptyInitForField(
unsigned Init,
FieldDecl *Field,
492 bool FillWithNoInit =
false);
496 bool FillWithNoInit =
false);
499 bool TopLevelObject);
506 bool VerifyOnly,
bool TreatUnavailableAsInvalid,
507 bool InOverloadResolution =
false,
512 : InitListChecker(S, Entity, IL,
T,
true,
515 &AggrDeductionCandidateParamTypes){};
517 bool HadError() {
return hadError; }
521 InitListExpr *getFullyStructuredList()
const {
return FullyStructuredList; }
538 bool EmptyInitList = SemaRef.
getLangOpts().CPlusPlus11 &&
551 InitExpr = VerifyOnly
569 if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
573 InitSeq.getFailedCandidateSet()
574 .BestViableFunction(SemaRef,
Kind.getLocation(), Best);
576 assert(O ==
OR_Success &&
"Inconsistent overload resolution");
583 bool IsInStd =
false;
585 ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
590 if (IsInStd && llvm::StringSwitch<bool>(R->
getName())
591 .Cases(
"basic_string",
"deque",
"forward_list",
true)
592 .Cases(
"list",
"map",
"multimap",
"multiset",
true)
593 .Cases(
"priority_queue",
"queue",
"set",
"stack",
true)
594 .Cases(
"unordered_map",
"unordered_set",
"vector",
true)
596 InitSeq.InitializeFrom(
600 TreatUnavailableAsInvalid);
605 diag::warn_invalid_initializer_from_system_header);
608 diag::note_used_in_initialization_here);
610 SemaRef.
Diag(Loc, diag::note_used_in_initialization_here);
617 InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
620 diag::note_in_omitted_aggregate_initializer)
623 bool IsTrailingArrayNewMember =
626 SemaRef.
Diag(Loc, diag::note_in_omitted_aggregate_initializer)
627 << (IsTrailingArrayNewMember ? 2 : 0)
636 : InitSeq.Perform(SemaRef, Entity,
Kind, SubInit);
644 if (FullyStructuredList)
646 PerformEmptyInit(Loc, Entity);
649void InitListChecker::FillInEmptyInitForBase(
652 bool &RequiresSecondPass,
bool FillWithNoInit) {
659 : PerformEmptyInit(ILE->
getEndLoc(), BaseEntity);
666 assert(Init < ILE->getNumInits() &&
"should have been expanded");
671 FillInEmptyInitializations(BaseEntity, InnerILE, RequiresSecondPass,
672 ILE,
Init, FillWithNoInit);
674 dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(
Init))) {
675 FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),
676 RequiresSecondPass, ILE,
Init,
681void InitListChecker::FillInEmptyInitForField(
unsigned Init,
FieldDecl *Field,
684 bool &RequiresSecondPass,
685 bool FillWithNoInit) {
693 if (!RType->getDecl()->isUnion())
694 assert((
Init < NumInits || VerifyOnly) &&
695 "This ILE should have been expanded");
697 if (FillWithNoInit) {
698 assert(!VerifyOnly &&
"should not fill with no-init in verify-only mode");
710 if (
Field->hasInClassInitializer()) {
724 RequiresSecondPass =
true;
729 if (
Field->getType()->isReferenceType()) {
735 SemaRef.
Diag(Loc, diag::err_init_reference_member_uninitialized)
739 SemaRef.
Diag(
Field->getLocation(), diag::note_uninit_reference_member);
745 ExprResult MemberInit = PerformEmptyInit(Loc, MemberEntity);
751 if (hadError || VerifyOnly) {
753 }
else if (
Init < NumInits) {
755 }
else if (!isa<ImplicitValueInitExpr>(MemberInit.
get())) {
761 RequiresSecondPass =
true;
765 FillInEmptyInitializations(MemberEntity, InnerILE,
766 RequiresSecondPass, ILE,
Init, FillWithNoInit);
768 dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(
Init))) {
769 FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
770 RequiresSecondPass, ILE,
Init,
781 bool &RequiresSecondPass,
784 bool FillWithNoInit) {
786 "Should not have void type");
790 if (FillWithNoInit && VerifyOnly)
800 struct UpdateOuterILEWithUpdatedInit {
803 ~UpdateOuterILEWithUpdatedInit() {
807 } UpdateOuterRAII = {OuterILE, OuterIndex};
818 Entity, ILE, RequiresSecondPass, FillWithNoInit);
819 else if (RDecl->
isUnion() && isa<CXXRecordDecl>(RDecl) &&
820 cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
821 for (
auto *Field : RDecl->
fields()) {
822 if (
Field->hasInClassInitializer()) {
823 FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass,
832 unsigned NumElems = numStructUnionElements(ILE->
getType());
840 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {
841 for (
auto &
Base : CXXRD->bases()) {
845 FillInEmptyInitForBase(
Init,
Base, Entity, ILE, RequiresSecondPass,
851 for (
auto *Field : RDecl->
fields()) {
852 if (
Field->isUnnamedBitField())
858 FillInEmptyInitForField(
Init, Field, Entity, ILE, RequiresSecondPass,
878 unsigned NumElements = NumInits;
880 ElementType = AType->getElementType();
881 if (
const auto *CAType = dyn_cast<ConstantArrayType>(AType))
882 NumElements = CAType->getZExtSize();
890 ElementType = VType->getElementType();
891 NumElements = VType->getNumElements();
897 bool SkipEmptyInitChecks =
false;
910 if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
915 if (SkipEmptyInitChecks)
918 Expr *Filler =
nullptr;
924 PerformEmptyInit(ILE->
getEndLoc(), ElementEntity);
935 }
else if (VerifyOnly) {
936 SkipEmptyInitChecks =
true;
937 }
else if (
Init < NumInits) {
952 if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {
958 RequiresSecondPass =
true;
962 = dyn_cast_or_null<InitListExpr>(InitExpr)) {
963 FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
964 ILE,
Init, FillWithNoInit);
966 dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr)) {
967 FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
968 RequiresSecondPass, ILE,
Init,
976 if (isa_and_nonnull<DesignatedInitExpr>(
Init))
981InitListChecker::InitListChecker(
983 bool VerifyOnly,
bool TreatUnavailableAsInvalid,
bool InOverloadResolution,
985 : SemaRef(S), VerifyOnly(VerifyOnly),
986 TreatUnavailableAsInvalid(TreatUnavailableAsInvalid),
987 InOverloadResolution(InOverloadResolution),
988 AggrDeductionCandidateParamTypes(AggrDeductionCandidateParamTypes) {
990 FullyStructuredList =
999 CheckExplicitInitList(Entity, IL,
T, FullyStructuredList,
1002 if (!hadError && !AggrDeductionCandidateParamTypes && FullyStructuredList) {
1003 bool RequiresSecondPass =
false;
1004 FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass,
1006 if (RequiresSecondPass && !hadError)
1007 FillInEmptyInitializations(Entity, FullyStructuredList,
1008 RequiresSecondPass,
nullptr, 0);
1010 if (hadError && FullyStructuredList)
1014int InitListChecker::numArrayElements(
QualType DeclType) {
1016 int maxElements = 0x7FFFFFFF;
1019 maxElements =
static_cast<int>(CAT->getZExtSize());
1024int InitListChecker::numStructUnionElements(
QualType DeclType) {
1026 int InitializableMembers = 0;
1027 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl))
1028 InitializableMembers += CXXRD->getNumBases();
1029 for (
const auto *Field : structDecl->
fields())
1030 if (!
Field->isUnnamedBitField())
1031 ++InitializableMembers;
1034 return std::min(InitializableMembers, 1);
1040 return RT->getDecl();
1042 return Inject->getDecl();
1072 if (
CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(ParentRD)) {
1073 if (CXXRD->getNumBases()) {
1077 auto FieldIt = ParentRD->field_begin();
1078 assert(FieldIt != ParentRD->field_end() &&
1079 "no fields but have initializer for member?");
1080 return ++FieldIt == ParentRD->field_end();
1096 unsigned &StructuredIndex) {
1097 int maxElements = 0;
1100 maxElements = numArrayElements(
T);
1102 maxElements = numStructUnionElements(
T);
1106 llvm_unreachable(
"CheckImplicitInitList(): Illegal type");
1108 if (maxElements == 0) {
1111 diag::err_implicit_empty_initializer);
1118 InitListExpr *StructuredSubobjectInitList = getStructuredSubobjectInit(
1119 ParentIList, Index,
T, StructuredList, StructuredIndex,
1122 unsigned StructuredSubobjectInitIndex = 0;
1125 unsigned StartIndex = Index;
1126 CheckListElementTypes(Entity, ParentIList,
T,
1128 StructuredSubobjectInitList,
1129 StructuredSubobjectInitIndex);
1131 if (StructuredSubobjectInitList) {
1132 StructuredSubobjectInitList->
setType(
T);
1134 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
1137 if (EndIndex < ParentIList->getNumInits() &&
1138 ParentIList->
getInit(EndIndex)) {
1149 diag::warn_missing_braces)
1155 StructuredSubobjectInitList->
getEndLoc()),
1161 if (!VerifyOnly && CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1163 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1179 unsigned DiagID = 0;
1191 DiagID = diag::warn_braces_around_init;
1198 DiagID = diag::warn_braces_around_init;
1224 llvm_unreachable(
"unexpected braced scalar init");
1243 bool TopLevelObject) {
1244 unsigned Index = 0, StructuredIndex = 0;
1245 CheckListElementTypes(Entity, IList,
T,
true,
1246 Index, StructuredList, StructuredIndex, TopLevelObject);
1247 if (StructuredList) {
1253 StructuredList->
setType(ExprTy);
1261 bool ExtraInitsIsError = SemaRef.
getLangOpts().CPlusPlus ||
1263 hadError = ExtraInitsIsError;
1266 }
else if (StructuredIndex == 1 &&
1271 ? diag::err_excess_initializers_in_char_array_initializer
1272 : diag::ext_excess_initializers_in_char_array_initializer;
1276 unsigned DK = ExtraInitsIsError
1277 ? diag::err_excess_initializers_for_sizeless_type
1278 : diag::ext_excess_initializers_for_sizeless_type;
1288 unsigned DK = ExtraInitsIsError ? diag::err_excess_initializers
1289 : diag::ext_excess_initializers;
1297 !isa<InitListExpr>(IList->
getInit(0)))
1303 if (CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1306 bool HasEquivCtor =
false;
1312 if (!HasEquivCtor) {
1314 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1324 bool SubobjectIsDesignatorContext,
1327 unsigned &StructuredIndex,
1328 bool TopLevelObject) {
1332 CheckComplexType(Entity, IList, DeclType, Index,
1333 StructuredList, StructuredIndex);
1335 CheckScalarType(Entity, IList, DeclType, Index,
1336 StructuredList, StructuredIndex);
1338 CheckVectorType(Entity, IList, DeclType, Index,
1339 StructuredList, StructuredIndex);
1340 }
else if (
const RecordDecl *RD = getRecordDecl(DeclType)) {
1346 "non-aggregate records should be handed in CheckSubElementType");
1347 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1348 Bases = CXXRD->bases();
1350 Bases = cast<CXXRecordDecl>(RD)->bases();
1352 CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(),
1353 SubobjectIsDesignatorContext, Index, StructuredList,
1354 StructuredIndex, TopLevelObject);
1359 CheckArrayType(Entity, IList, DeclType, Zero,
1360 SubobjectIsDesignatorContext, Index,
1361 StructuredList, StructuredIndex);
1366 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1370 CheckReferenceType(Entity, IList, DeclType, Index,
1371 StructuredList, StructuredIndex);
1374 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_init_objc_class) << DeclType;
1379 CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1386 assert(AggrDeductionCandidateParamTypes);
1387 AggrDeductionCandidateParamTypes->push_back(DeclType);
1390 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1401 unsigned &StructuredIndex,
1402 bool DirectlyDesignated) {
1406 return CheckReferenceType(Entity, IList, ElemType, Index,
1407 StructuredList, StructuredIndex);
1410 if (SubInitList->getNumInits() == 1 &&
1415 expr = SubInitList->getInit(0);
1418 }
else if (isa<ImplicitValueInitExpr>(
expr)) {
1422 "found implicit initialization for the wrong type");
1423 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1445 if (TmpEntity.getType()->isDependentType()) {
1450 assert(AggrDeductionCandidateParamTypes);
1451 if (!isa_and_nonnull<ConstantArrayType>(
1454 AggrDeductionCandidateParamTypes->push_back(ElemType);
1466 if (
Seq || isa<InitListExpr>(
expr)) {
1469 if (Result.isInvalid())
1472 UpdateStructuredListElement(StructuredList, StructuredIndex,
1473 Result.getAs<
Expr>());
1476 }
else if (StructuredList) {
1477 UpdateStructuredListElement(StructuredList, StructuredIndex,
1481 if (AggrDeductionCandidateParamTypes)
1482 AggrDeductionCandidateParamTypes->push_back(ElemType);
1490 return CheckScalarType(Entity, IList, ElemType, Index,
1491 StructuredList, StructuredIndex);
1505 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1534 UpdateStructuredListElement(StructuredList, StructuredIndex,
1552 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
1557 if (DirectlyDesignated && SemaRef.
getLangOpts().CPlusPlus && !hadError) {
1558 if (InOverloadResolution)
1562 diag::ext_designated_init_brace_elision)
1563 <<
expr->getSourceRange()
1578 assert(
Copy.isInvalid() &&
1579 "expected non-aggregate initialization to fail");
1591 unsigned &StructuredIndex) {
1592 assert(Index == 0 &&
"Index in explicit init list must be zero");
1602 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1607 if (!SemaRef.
getLangOpts().CPlusPlus && !VerifyOnly)
1616 for (
unsigned i = 0; i < 2; ++i) {
1618 CheckSubElementType(ElementEntity, IList, elementType, Index,
1619 StructuredList, StructuredIndex);
1627 unsigned &StructuredIndex) {
1634 ? diag::warn_cxx98_compat_empty_sizeless_initializer
1635 : diag::err_empty_sizeless_initializer)
1640 ? diag::warn_cxx98_compat_empty_scalar_initializer
1641 : diag::err_empty_scalar_initializer)
1657 SemaRef.
Diag(SubIList->getBeginLoc(), diag::ext_many_braces_around_init)
1660 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1663 }
else if (isa<DesignatedInitExpr>(
expr)) {
1666 diag::err_designator_for_scalar_or_sizeless_init)
1668 <<
expr->getSourceRange();
1678 Result = getDummyInit();
1687 Expr *ResultExpr =
nullptr;
1689 if (Result.isInvalid())
1692 ResultExpr = Result.getAs<
Expr>();
1694 if (ResultExpr !=
expr && !VerifyOnly) {
1697 IList->
setInit(Index, ResultExpr);
1700 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1702 if (AggrDeductionCandidateParamTypes)
1703 AggrDeductionCandidateParamTypes->push_back(DeclType);
1710 unsigned &StructuredIndex) {
1718 diag::err_init_reference_member_uninitialized)
1740 Result = getDummyInit();
1749 if (Result.isInvalid())
1754 if (!VerifyOnly &&
expr)
1757 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1759 if (AggrDeductionCandidateParamTypes)
1760 AggrDeductionCandidateParamTypes->push_back(DeclType);
1767 unsigned &StructuredIndex) {
1770 unsigned numEltsInit = 0;
1775 CheckEmptyInitializable(
1785 if (!isa<InitListExpr>(
Init) &&
Init->getType()->isVectorType()) {
1789 Result = getDummyInit();
1798 Expr *ResultExpr =
nullptr;
1799 if (Result.isInvalid())
1802 ResultExpr = Result.getAs<
Expr>();
1804 if (ResultExpr !=
Init && !VerifyOnly) {
1807 IList->
setInit(Index, ResultExpr);
1810 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1812 if (AggrDeductionCandidateParamTypes)
1813 AggrDeductionCandidateParamTypes->push_back(elementType);
1820 for (
unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1823 CheckEmptyInitializable(ElementEntity, IList->
getEndLoc());
1828 CheckSubElementType(ElementEntity, IList, elementType, Index,
1829 StructuredList, StructuredIndex);
1837 if (isBigEndian && (
T->getVectorKind() == VectorKind::Neon ||
1838 T->getVectorKind() == VectorKind::NeonPoly)) {
1850 diag::warn_neon_vector_initializer_non_portable);
1852 const char *typeCode;
1862 llvm_unreachable(
"Invalid element type!");
1866 ? diag::note_neon_vector_initializer_non_portable_q
1867 : diag::note_neon_vector_initializer_non_portable)
1868 << typeCode << typeSize;
1878 for (
unsigned i = 0; i < maxElements; ++i) {
1887 CheckSubElementType(ElementEntity, IList, elementType, Index,
1888 StructuredList, StructuredIndex);
1900 CheckSubElementType(ElementEntity, IList, VecType, Index,
1901 StructuredList, StructuredIndex);
1902 numEltsInit += numIElts;
1907 if (numEltsInit != maxElements) {
1910 diag::err_vector_incorrect_num_initializers)
1911 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1934 SemaRef.
PDiag(diag::err_access_dtor_temp)
1942 llvm::APSInt elementIndex,
1943 bool SubobjectIsDesignatorContext,
1946 unsigned &StructuredIndex) {
1958 if (Index < IList->getNumInits()) {
1971 if (StructuredList) {
1972 UpdateStructuredListElement(StructuredList, StructuredIndex,
1977 if (AggrDeductionCandidateParamTypes)
1978 AggrDeductionCandidateParamTypes->push_back(DeclType);
1999 SemaRef.
Diag(VAT->getSizeExpr()->getBeginLoc(),
2000 diag::err_variable_object_no_init)
2001 << VAT->getSizeExpr()->getSourceRange();
2010 llvm::APSInt maxElements(elementIndex.getBitWidth(),
2011 elementIndex.isUnsigned());
2012 bool maxElementsKnown =
false;
2014 maxElements = CAT->getSize();
2015 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
2016 elementIndex.setIsUnsigned(maxElements.isUnsigned());
2017 maxElementsKnown =
true;
2021 while (Index < IList->getNumInits()) {
2027 if (!SubobjectIsDesignatorContext)
2032 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
2033 DeclType,
nullptr, &elementIndex, Index,
2034 StructuredList, StructuredIndex,
true,
2040 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
2041 maxElements = maxElements.extend(elementIndex.getBitWidth());
2042 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
2043 elementIndex = elementIndex.extend(maxElements.getBitWidth());
2044 elementIndex.setIsUnsigned(maxElements.isUnsigned());
2048 if (!maxElementsKnown && elementIndex > maxElements)
2049 maxElements = elementIndex;
2056 if (maxElementsKnown && elementIndex == maxElements)
2063 CheckSubElementType(ElementEntity, IList, elementType, Index,
2064 StructuredList, StructuredIndex);
2069 if (!maxElementsKnown && elementIndex > maxElements)
2070 maxElements = elementIndex;
2075 llvm::APSInt
Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
2079 SemaRef.
Diag(IList->
getBeginLoc(), diag::ext_typecheck_zero_array_size);
2083 elementType, maxElements,
nullptr, ArraySizeModifier::Normal, 0);
2090 if ((maxElementsKnown && elementIndex < maxElements) ||
2092 CheckEmptyInitializable(
2101 bool TopLevelObject) {
2103 unsigned FlexArrayDiag;
2104 if (isa<InitListExpr>(InitExpr) &&
2105 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
2107 FlexArrayDiag = diag::ext_flexible_array_init;
2108 }
else if (!TopLevelObject) {
2110 FlexArrayDiag = diag::err_flexible_array_init;
2113 FlexArrayDiag = diag::err_flexible_array_init;
2114 }
else if (cast<VarDecl>(Entity.
getDecl())->hasLocalStorage()) {
2116 FlexArrayDiag = diag::err_flexible_array_init;
2119 FlexArrayDiag = diag::ext_flexible_array_init;
2125 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2129 return FlexArrayDiag != diag::ext_flexible_array_init;
2132void InitListChecker::CheckStructUnionTypes(
2135 bool SubobjectIsDesignatorContext,
unsigned &Index,
2136 InitListExpr *StructuredList,
unsigned &StructuredIndex,
2137 bool TopLevelObject) {
2138 const RecordDecl *RD = getRecordDecl(DeclType);
2160 if (isa<CXXRecordDecl>(RD) &&
2161 cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
2162 if (!StructuredList)
2165 Field != FieldEnd; ++Field) {
2166 if (
Field->hasInClassInitializer()) {
2177 Field != FieldEnd; ++Field) {
2178 if (!
Field->isUnnamedBitField()) {
2179 CheckEmptyInitializable(
2190 bool InitializedSomething =
false;
2193 for (
auto I = Bases.begin(), E = Bases.end(); I != E; ++I) {
2199 if (
Init && isa<DesignatedInitExpr>(
Init))
2216 if (AggrDeductionCandidateParamTypes &&
Base.isPackExpansion()) {
2217 AggrDeductionCandidateParamTypes->push_back(
2222 if (Index < IList->getNumInits())
2234 CheckSubElementType(BaseEntity, IList,
Base.getType(), Index,
2235 StructuredList, StructuredIndex);
2236 InitializedSomething =
true;
2238 CheckEmptyInitializable(BaseEntity, InitLoc);
2253 size_t NumRecordDecls = llvm::count_if(RD->
decls(), [&](
const Decl *D) {
2254 return isa<FieldDecl>(D) || isa<RecordDecl>(D);
2256 bool HasDesignatedInit =
false;
2260 while (Index < IList->getNumInits()) {
2268 if (!SubobjectIsDesignatorContext)
2271 HasDesignatedInit =
true;
2275 bool DesignatedInitFailed = CheckDesignatedInitializer(
2276 Entity, IList, DIE, 0, DeclType, &Field,
nullptr, Index,
2277 StructuredList, StructuredIndex,
true, TopLevelObject);
2278 if (DesignatedInitFailed)
2285 InitializedFields.insert(F);
2286 if (!DesignatedInitFailed) {
2295 InitializedSomething =
true;
2312 if (NumRecordDecls == 1)
2314 if (
const auto *IL = dyn_cast<IntegerLiteral>(I))
2315 return IL->getValue().isZero();
2323 SemaRef.
Diag(InitLoc, diag::err_non_designated_init_used);
2328 if (Field == FieldEnd) {
2334 if (InitializedSomething && RD->
isUnion())
2338 if (
Field->getType()->isIncompleteArrayType())
2341 if (
Field->isUnnamedBitField()) {
2350 InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
2371 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2372 StructuredList, StructuredIndex);
2373 InitializedSomething =
true;
2374 InitializedFields.insert(*Field);
2376 if (RD->
isUnion() && StructuredList) {
2387 bool IsCDesignatedInitializer =
2388 HasDesignatedInit && !SemaRef.
getLangOpts().CPlusPlus;
2389 if (!VerifyOnly && InitializedSomething && !RD->
isUnion() &&
2391 !IsCDesignatedInitializer) {
2398 if (HasDesignatedInit && InitializedFields.count(*it))
2401 if (!it->isUnnamedBitField() && !it->hasInClassInitializer() &&
2402 !it->getType()->isIncompleteArrayType()) {
2403 auto Diag = HasDesignatedInit
2404 ? diag::warn_missing_designated_field_initializers
2405 : diag::warn_missing_field_initializers;
2414 if (!StructuredList && Field != FieldEnd && !RD->
isUnion() &&
2415 !
Field->getType()->isIncompleteArrayType()) {
2416 for (;
Field != FieldEnd && !hadError; ++
Field) {
2417 if (!
Field->isUnnamedBitField() && !
Field->hasInClassInitializer())
2418 CheckEmptyInitializable(
2439 if (Field == FieldEnd || !
Field->getType()->isIncompleteArrayType() ||
2443 if (CheckFlexibleArrayInit(Entity, IList->
getInit(Index), *Field,
2453 if (isa<InitListExpr>(IList->
getInit(Index)) ||
2454 AggrDeductionCandidateParamTypes)
2455 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2456 StructuredList, StructuredIndex);
2458 CheckImplicitInitList(MemberEntity, IList,
Field->getType(), Index,
2459 StructuredList, StructuredIndex);
2461 if (RD->
isUnion() && StructuredList) {
2480 PE = IndirectField->
chain_end(); PI != PE; ++PI) {
2488 assert(isa<FieldDecl>(*PI));
2489 Replacements.back().setFieldDecl(cast<FieldDecl>(*PI));
2496 &Replacements[0] + Replacements.size());
2503 for (
unsigned I = 0; I < NumIndexExprs; ++I)
2517 explicit FieldInitializerValidatorCCC(
const RecordDecl *RD)
2525 std::unique_ptr<CorrectionCandidateCallback>
clone()
override {
2526 return std::make_unique<FieldInitializerValidatorCCC>(*
this);
2579 llvm::APSInt *NextElementIndex,
2582 unsigned &StructuredIndex,
2583 bool FinishSubobjectInit,
2584 bool TopLevelObject) {
2585 if (DesigIdx == DIE->
size()) {
2592 assert(isa<InitListExpr>(
Init) &&
2593 "designator result in direct non-list initialization?");
2598 if (StructuredList) {
2602 UpdateStructuredListElement(StructuredList, StructuredIndex,
2606 if (AggrDeductionCandidateParamTypes)
2607 AggrDeductionCandidateParamTypes->push_back(CurrentObjectType);
2612 bool prevHadError = hadError;
2617 unsigned OldIndex = Index;
2620 CheckSubElementType(Entity, IList, CurrentObjectType, Index, StructuredList,
2621 StructuredIndex,
true);
2627 IList->
setInit(OldIndex, DIE);
2629 return hadError && !prevHadError;
2633 bool IsFirstDesignator = (DesigIdx == 0);
2634 if (IsFirstDesignator ? FullyStructuredList : StructuredList) {
2637 if (IsFirstDesignator)
2638 StructuredList = FullyStructuredList;
2640 Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2641 StructuredList->getInit(StructuredIndex) :
nullptr;
2642 if (!ExistingInit && StructuredList->hasArrayFiller())
2643 ExistingInit = StructuredList->getArrayFiller();
2646 StructuredList = getStructuredSubobjectInit(
2647 IList, Index, CurrentObjectType, StructuredList, StructuredIndex,
2649 else if (
InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2650 StructuredList = Result;
2663 diagnoseInitOverride(ExistingInit,
2670 dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2671 StructuredList = E->getUpdater();
2676 StructuredList->updateInit(SemaRef.
Context, StructuredIndex, DIUE);
2685 StructuredList =
nullptr;
2701 RecordDecl *RD = getRecordDecl(CurrentObjectType);
2707 SemaRef.
Diag(Loc, diag::err_field_designator_non_aggr)
2708 << SemaRef.
getLangOpts().CPlusPlus << CurrentObjectType;
2717 if (
auto *FD = dyn_cast_if_present<FieldDecl>(VD)) {
2719 }
else if (
auto *IFD = dyn_cast_if_present<IndirectFieldDecl>(VD)) {
2725 KnownField = cast<FieldDecl>(*IFD->chain_begin());
2744 SemaRef.
Diag(Lookup.front()->getLocation(),
2745 diag::note_field_designator_found);
2752 FieldInitializerValidatorCCC CCC(RD);
2759 SemaRef.
PDiag(diag::err_field_designator_unknown_suggest)
2760 << FieldName << CurrentObjectType);
2761 KnownField = Corrected.getCorrectionDeclAs<
FieldDecl>();
2772 SemaRef.
Diag(Loc, diag::err_field_designator_unknown)
2780 unsigned NumBases = 0;
2781 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2782 NumBases = CXXRD->getNumBases();
2784 unsigned FieldIndex = NumBases;
2786 for (
auto *FI : RD->
fields()) {
2787 if (FI->isUnnamedBitField())
2803 if (StructuredList) {
2804 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2806 assert(StructuredList->getNumInits() == 1
2807 &&
"A union should never have more than one initializer!");
2809 Expr *ExistingInit = StructuredList->getInit(0);
2812 diagnoseInitOverride(
2820 StructuredList->resizeInits(SemaRef.
Context, 0);
2821 StructuredList->setInitializedFieldInUnion(
nullptr);
2824 StructuredList->setInitializedFieldInUnion(*Field);
2831 InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
2854 if (IsFirstDesignator && !VerifyOnly && SemaRef.
getLangOpts().CPlusPlus &&
2857 (*NextField)->getFieldIndex() >
Field->getFieldIndex() + 1)) {
2861 if (FI->isUnnamedBitField())
2872 diag::ext_designated_init_reordered)
2875 unsigned OldIndex = StructuredIndex - 1;
2876 if (StructuredList && OldIndex <= StructuredList->getNumInits()) {
2877 if (
Expr *PrevInit = StructuredList->getInit(OldIndex)) {
2878 SemaRef.
Diag(PrevInit->getBeginLoc(),
2879 diag::note_previous_field_init)
2893 if (StructuredList && FieldIndex >= StructuredList->getNumInits())
2894 StructuredList->resizeInits(SemaRef.
Context, FieldIndex + 1);
2897 if (
Field->getType()->isIncompleteArrayType()) {
2899 if ((DesigIdx + 1) != DIE->
size()) {
2906 diag::err_designator_into_flexible_array_member)
2908 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2914 if (!hadError && !isa<InitListExpr>(DIE->
getInit()) &&
2915 !isa<StringLiteral>(DIE->
getInit())) {
2919 diag::err_flexible_array_init_needs_braces)
2921 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2928 if (!
Invalid && CheckFlexibleArrayInit(Entity, DIE->
getInit(), *Field,
2938 bool prevHadError = hadError;
2939 unsigned newStructuredIndex = FieldIndex;
2940 unsigned OldIndex = Index;
2945 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2946 StructuredList, newStructuredIndex);
2948 IList->
setInit(OldIndex, DIE);
2949 if (hadError && !prevHadError) {
2954 StructuredIndex = FieldIndex;
2960 unsigned newStructuredIndex = FieldIndex;
2964 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2965 FieldType,
nullptr,
nullptr, Index,
2966 StructuredList, newStructuredIndex,
2967 FinishSubobjectInit,
false))
2978 if (IsFirstDesignator) {
2985 StructuredIndex = FieldIndex;
2989 if (!FinishSubobjectInit)
2997 bool prevHadError = hadError;
3002 CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,
3003 false, Index, StructuredList, FieldIndex);
3004 return hadError && !prevHadError;
3026 << CurrentObjectType;
3031 Expr *IndexExpr =
nullptr;
3032 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
3036 DesignatedEndIndex = DesignatedStartIndex;
3040 DesignatedStartIndex =
3042 DesignatedEndIndex =
3051 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
3056 if (isa<ConstantArrayType>(AT)) {
3057 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(),
false);
3058 DesignatedStartIndex
3059 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
3060 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
3062 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
3063 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
3064 if (DesignatedEndIndex >= MaxElements) {
3067 diag::err_array_designator_too_large)
3074 unsigned DesignatedIndexBitWidth =
3076 DesignatedStartIndex =
3077 DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
3078 DesignatedEndIndex =
3079 DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
3080 DesignatedStartIndex.setIsUnsigned(
true);
3081 DesignatedEndIndex.setIsUnsigned(
true);
3084 bool IsStringLiteralInitUpdate =
3085 StructuredList && StructuredList->isStringLiteralInit();
3086 if (IsStringLiteralInitUpdate && VerifyOnly) {
3089 StructuredList =
nullptr;
3090 }
else if (IsStringLiteralInitUpdate) {
3103 unsigned PromotedCharTyWidth = Context.
getTypeSize(PromotedCharTy);
3108 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
3109 StrLen = cast<ConstantArrayType>(AT)->getZExtSize();
3110 StructuredList->resizeInits(Context, StrLen);
3114 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
3115 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
3117 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
3118 if (CharTy != PromotedCharTy)
3122 StructuredList->updateInit(Context, i,
Init);
3131 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
3132 StrLen = cast<ConstantArrayType>(AT)->getZExtSize();
3133 StructuredList->resizeInits(Context, StrLen);
3137 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
3138 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
3140 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
3141 if (CharTy != PromotedCharTy)
3145 StructuredList->updateInit(Context, i,
Init);
3152 if (StructuredList &&
3153 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
3154 StructuredList->resizeInits(SemaRef.
Context,
3155 DesignatedEndIndex.getZExtValue() + 1);
3161 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
3162 unsigned OldIndex = Index;
3167 while (DesignatedStartIndex <= DesignatedEndIndex) {
3173 if (CheckDesignatedInitializer(
3174 ElementEntity, IList, DIE, DesigIdx + 1, ElementType,
nullptr,
3175 nullptr, Index, StructuredList, ElementIndex,
3176 FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),
3181 ++DesignatedStartIndex;
3182 ElementIndex = DesignatedStartIndex.getZExtValue();
3187 if (IsFirstDesignator) {
3188 if (NextElementIndex)
3189 *NextElementIndex = DesignatedStartIndex;
3190 StructuredIndex = ElementIndex;
3194 if (!FinishSubobjectInit)
3198 bool prevHadError = hadError;
3199 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
3201 StructuredList, ElementIndex);
3202 return hadError && !prevHadError;
3208InitListChecker::getStructuredSubobjectInit(
InitListExpr *IList,
unsigned Index,
3211 unsigned StructuredIndex,
3213 bool IsFullyOverwritten) {
3214 if (!StructuredList)
3217 Expr *ExistingInit =
nullptr;
3218 if (StructuredIndex < StructuredList->getNumInits())
3219 ExistingInit = StructuredList->
getInit(StructuredIndex);
3221 if (
InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
3230 if (!IsFullyOverwritten)
3253 diagnoseInitOverride(ExistingInit, InitRange);
3256 unsigned ExpectedNumInits = 0;
3257 if (Index < IList->getNumInits()) {
3258 if (
auto *
Init = dyn_cast_or_null<InitListExpr>(IList->
getInit(Index)))
3259 ExpectedNumInits =
Init->getNumInits();
3265 createInitListExpr(CurrentObjectType, InitRange, ExpectedNumInits);
3274InitListChecker::createInitListExpr(
QualType CurrentObjectType,
3276 unsigned ExpectedNumInits) {
3280 QualType ResultType = CurrentObjectType;
3283 Result->setType(ResultType);
3286 unsigned NumElements = 0;
3291 NumElements = CAType->getZExtSize();
3294 if (NumElements > ExpectedNumInits)
3298 NumElements = VType->getNumElements();
3300 NumElements = numStructUnionElements(CurrentObjectType);
3305 Result->reserveInits(SemaRef.
Context, NumElements);
3312void InitListChecker::UpdateStructuredListElement(
InitListExpr *StructuredList,
3313 unsigned &StructuredIndex,
3316 if (!StructuredList)
3320 StructuredIndex,
expr)) {
3326 diagnoseInitOverride(PrevInit,
expr->getSourceRange());
3337 InitListChecker Check(*
this, Entity, From,
Type,
true,
3340 return !Check.HadError();
3361 return S.
Diag(Loc, diag::err_array_designator_negative)
3364 Value.setIsUnsigned(
true);
3383 Designators.push_back(ASTDesignator::CreateFieldDesignator(
3387 llvm::APSInt IndexValue;
3388 if (!Index->isTypeDependent() && !Index->isValueDependent())
3393 Designators.push_back(ASTDesignator::CreateArrayDesignator(
3395 InitExpressions.push_back(Index);
3400 llvm::APSInt StartValue;
3401 llvm::APSInt EndValue;
3406 if (!StartDependent)
3412 if (!StartIndex || !EndIndex)
3416 if (StartDependent || EndDependent) {
3418 }
else if (StartValue.getBitWidth() > EndValue.getBitWidth())
3419 EndValue = EndValue.extend(StartValue.getBitWidth());
3420 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
3421 StartValue = StartValue.extend(EndValue.getBitWidth());
3423 if (!StartDependent && !EndDependent && EndValue < StartValue) {
3429 Designators.push_back(ASTDesignator::CreateArrayRangeDesignator(
3432 InitExpressions.push_back(StartIndex);
3433 InitExpressions.push_back(EndIndex);
3443 EqualOrColonLoc, GNUSyntax,
3451InitializedEntity::InitializedEntity(
ASTContext &Context,
unsigned Index,
3456 Kind = EK_ArrayElement;
3459 Kind = EK_VectorElement;
3463 assert(CT &&
"Unexpected type");
3464 Kind = EK_ComplexElement;
3472 bool IsInheritedVirtualBase,
3477 Result.Base = {
Base, IsInheritedVirtualBase};
3495 return Variable.VariableOrMember->getDeclName();
3517 llvm_unreachable(
"Invalid EntityKind!");
3551 llvm_unreachable(
"Invalid EntityKind!");
3586unsigned InitializedEntity::dumpImpl(raw_ostream &OS)
const {
3589 for (
unsigned I = 0; I != Depth; ++I)
3606 case EK_New: OS <<
"New";
break;
3610 case EK_Base: OS <<
"Base";
break;
3617 OS <<
"Block (lambda)";
3620 OS <<
"LambdaCapture ";
3627 D->printQualifiedName(OS);
3630 OS <<
" '" <<
getType() <<
"'\n";
3636 dumpImpl(llvm::errs());
3691 for (
const Step &S : llvm::reverse(Steps)) {
3751 llvm_unreachable(
"Invalid EntityKind!");
3759InitializationSequence
3762 bool HadMultipleCandidates) {
3766 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3768 S.Function.FoundDecl = Found;
3787 bool BindingTemporary) {
3812 bool HadMultipleCandidates) {
3816 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3818 S.Function.FoundDecl = FoundDecl;
3857 bool TopLevelOfInitList) {
3875 bool HadMultipleCandidates,
bool FromInitList,
bool AsInitList) {
3881 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3882 S.Function.Function = Constructor;
3883 S.Function.FoundDecl = FoundDecl;
3926 Steps.insert(Steps.begin(), S);
3987 "Can only rewrap trivial init lists.");
3991 Steps.insert(Steps.begin(), S);
3995 S.WrappingSyntacticList = Syntactic;
4002 this->Failure = Failure;
4003 this->FailedOverloadResult =
Result;
4024 if (!
Init.empty()) {
4044 "consuming an object of unretainable type?");
4065 bool TreatUnavailableAsInvalid);
4076 bool TreatUnavailableAsInvalid) {
4090 List->getNumInits()),
4095 List->getExprLoc(), List->getBeginLoc(), List->getEndLoc());
4097 TreatUnavailableAsInvalid);
4124 bool CopyInitializing,
bool AllowExplicit,
bool OnlyListConstructors,
4125 bool IsListInit,
bool RequireActualConstructor,
4126 bool SecondStepOfCopyInit =
false) {
4132 if (!Info.Constructor || Info.Constructor->isInvalidDecl())
4149 bool SuppressUserConversions =
4150 SecondStepOfCopyInit ||
4151 (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
4154 if (Info.ConstructorTmpl)
4156 Info.ConstructorTmpl, Info.FoundDecl,
4157 nullptr, Args, CandidateSet, SuppressUserConversions,
4158 false, AllowExplicit);
4167 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
4171 CandidateSet, SuppressUserConversions,
4172 false, AllowExplicit,
4188 if (S.
getLangOpts().CPlusPlus17 && Args.size() == 1 &&
4189 !RequireActualConstructor && !SecondStepOfCopyInit) {
4191 auto *SourceRD =
Initializer->getType()->getAsCXXRecordDecl();
4193 const auto &Conversions = SourceRD->getVisibleConversionFunctions();
4194 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4204 Conv = cast<CXXConversionDecl>(D);
4208 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4209 CandidateSet, AllowExplicit, AllowExplicit,
4213 DestType, CandidateSet, AllowExplicit,
4240 bool IsListInit =
false,
4241 bool IsInitListCopy =
false) {
4242 assert(((!IsListInit && !IsInitListCopy) ||
4243 (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
4244 "IsListInit/IsInitListCopy must come with a single initializer list "
4247 (IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) :
nullptr;
4257 bool RequireActualConstructor =
4272 if (S.
getLangOpts().CPlusPlus17 && !RequireActualConstructor &&
4273 UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isPRValue() &&
4283 assert(DestRecordType &&
"Constructor initialization requires record type");
4285 = cast<CXXRecordDecl>(DestRecordType->
getDecl());
4293 bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
4303 bool AsInitializerList =
false;
4315 AsInitializerList =
true;
4321 S, Kind.getLocation(), Args, CandidateSet, DestType, Ctors, Best,
4322 CopyInitialization, AllowExplicit,
4323 true, IsListInit, RequireActualConstructor);
4332 AsInitializerList =
false;
4334 S, Kind.getLocation(), UnwrappedArgs, CandidateSet, DestType, Ctors,
4335 Best, CopyInitialization, AllowExplicit,
4336 false, IsListInit, RequireActualConstructor);
4348 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4352 if (
auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
4354 QualType ConvType = CD->getConversionType();
4356 "should not have selected this conversion function");
4358 HadMultipleCandidates);
4389 if (IsListInit && !Kind.AllowExplicit() && CtorDecl->
isExplicit()) {
4409 Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,
4410 IsListInit | IsInitListCopy, AsInitializerList);
4423 bool HadMultipleCandidates =
false;
4426 UnqualifiedTargetType,
4428 &HadMultipleCandidates)) {
4430 HadMultipleCandidates);
4431 SourceType = Fn->getType();
4450 bool TopLevelOfInitList);
4464 bool TreatUnavailableAsInvalid) {
4504 T1Quals, cv2T2, T2, T2Quals, Sequence,
4535 TreatUnavailableAsInvalid);
4567 bool TreatUnavailableAsInvalid) {
4579 TreatUnavailableAsInvalid);
4617 !IsDesignatedInit) {
4622 Expr *InitListAsExpr = InitList;
4632 if (!isa<VariableArrayType>(DestAT) &&
4642 TreatUnavailableAsInvalid);
4675 TreatUnavailableAsInvalid))
4679 Expr *InitListAsExpr = InitList;
4681 DestType, Sequence,
true);
4699 ET && ET->getDecl()->isFixed() &&
4748 if (
Init->getType()->isRecordType() ||
4759 TreatUnavailableAsInvalid);
4766 InitListChecker CheckInitList(S, Entity, InitList,
4767 DestType,
true, TreatUnavailableAsInvalid);
4768 if (CheckInitList.HadError()) {
4790 "Must have incompatible references when binding via conversion");
4801 bool AllowExplicitCtors =
false;
4802 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
4813 if (!Info.Constructor)
4816 if (!Info.Constructor->isInvalidDecl() &&
4817 Info.Constructor->isConvertingConstructor(
true)) {
4818 if (Info.ConstructorTmpl)
4820 Info.ConstructorTmpl, Info.FoundDecl,
4823 false, AllowExplicitCtors);
4826 Info.Constructor, Info.FoundDecl,
Initializer, CandidateSet,
4828 false, AllowExplicitCtors);
4843 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4846 if (isa<UsingShadowDecl>(D))
4847 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4854 Conv = cast<CXXConversionDecl>(D);
4862 if ((AllowRValues ||
4866 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4868 false, AllowExplicitConvs);
4871 Conv, I.getPair(), ActingDC,
Initializer, DestType, CandidateSet,
4872 false, AllowExplicitConvs);
4894 if (isa<CXXConversionDecl>(
Function))
4907 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4909 HadMultipleCandidates);
4919 assert(!isa<CXXConstructorDecl>(
Function) &&
4920 "should not have conversion after constructor");
4924 ICS.
Standard = Best->FinalConversion;
4945 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
4947 else if (RefConv & Sema::ReferenceConversions::ObjC)
4949 else if (RefConv & Sema::ReferenceConversions::Function)
4951 else if (RefConv & Sema::ReferenceConversions::Qualification) {
4968 bool TopLevelOfInitList) {
4986 T1Quals, cv2T2, T2, T2Quals, Sequence,
4987 TopLevelOfInitList);
5011 bool TopLevelOfInitList) {
5035 if (isLValueRef || T1Function) {
5038 (Kind.isCStyleOrFunctionalCast() &&
5042 if (RefConv & (Sema::ReferenceConversions::DerivedToBase |
5043 Sema::ReferenceConversions::ObjC)) {
5046 if (RefConv & (Sema::ReferenceConversions::Qualification))
5050 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
5054 }
else if (RefConv & Sema::ReferenceConversions::Qualification) {
5058 }
else if (RefConv & Sema::ReferenceConversions::Function) {
5078 (isLValueRef || InitCategory.
isRValue())) {
5083 isLValueRef, Sequence);
5117 switch (RefRelationship) {
5129 llvm_unreachable(
"unexpected kind of compatible initializer");
5153 (Kind.isCStyleOrFunctionalCast() &&
5182 auto T1QualsIgnoreAS = T1Quals;
5183 auto T2QualsIgnoreAS = T2Quals;
5186 T2QualsIgnoreAS.removeAddressSpace();
5189 if (T1QualsIgnoreAS != T2QualsIgnoreAS)
5199 cv1T4 = cv1T4WithAS;
5204 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
5206 else if (RefConv & Sema::ReferenceConversions::ObjC)
5208 else if (RefConv & Sema::ReferenceConversions::Qualification) {
5225 isLValueRef, Sequence);
5265 Sema::AllowedExplicit::None,
5267 Kind.isCStyleOrFunctionalCast(),
5286 TopLevelOfInitList);
5295 ((T1CVRQuals | T2CVRQuals) != T1CVRQuals ||
5340 assert((!InitList || InitList->
getNumInits() == 0) &&
5341 "Shouldn't use value-init for non-empty init lists");
5352 if (
CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
5353 bool NeedZeroInitialization =
true;
5368 NeedZeroInitialization =
false;
5376 if (NeedZeroInitialization)
5390 ClassDecl->hasUninitializedReferenceMember()) {
5398 Expr *InitListAsExpr = InitList;
5400 bool InitListSyntax = InitList;
5405 S, Entity, Kind, Args,
T, Entity.
getType(), Sequence, InitListSyntax);
5455 unsigned EntityIndexToProcess = 0;
5458 Expr *ArrayFiller =
nullptr;
5459 FieldDecl *InitializedFieldInUnion =
nullptr;
5463 Expr *Arg,
Expr **InitExpr =
nullptr) {
5465 S, SubEntity, SubKind, Arg ?
MultiExprArg(Arg) : std::nullopt);
5479 ER = IS.
Perform(S, SubEntity, SubKind,
5482 *InitExpr = ER.
get();
5484 InitExprs.push_back(ER.
get());
5492 uint64_t ArrayLength;
5500 ArrayLength = CAT->getZExtSize();
5501 ResultType = Entity.
getType();
5508 const Expr *SE = VAT->getSizeExpr();
5513 assert(isa<IncompleteArrayType>(Entity.
getType()));
5514 ArrayLength = Args.size();
5516 EntityIndexToProcess = ArrayLength;
5520 for (
Expr *E : Args) {
5525 if (!HandleInitializedEntity(SubEntity, SubKind, E))
5533 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
true);
5534 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr, &ArrayFiller))
5538 if (ResultType.
isNull()) {
5545 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
5559 if (EntityIndexToProcess < Args.size()) {
5565 Expr *E = Args[EntityIndexToProcess];
5568 if (!HandleInitializedEntity(SubEntity, SubKind, E))
5576 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
5578 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr))
5581 EntityIndexToProcess++;
5594 if (EntityIndexToProcess < Args.size()) {
5596 Expr *E = Args[EntityIndexToProcess];
5614 if (!HandleInitializedEntity(SubEntity, SubKind, E))
5622 InitializedFieldInUnion = FD;
5623 EntityIndexToProcess = 1;
5635 Kind.getParenOrBraceRange().getEnd(), FD);
5639 InitExprs.push_back(DIE.
get());
5649 S.
Diag(SR.
getEnd(), diag::err_init_reference_member_uninitialized)
5656 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
true);
5657 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr))
5661 EntityIndexToProcess++;
5663 ResultType = Entity.
getType();
5668 if (EntityIndexToProcess < Args.size()) {
5673 SourceRange ExcessInitSR(Args[EntityIndexToProcess]->getBeginLoc(),
5674 Args.back()->getEndLoc());
5675 S.
Diag(Kind.getLocation(), diag::err_excess_initializers)
5676 << InitKind << ExcessInitSR;
5690 CPLIE->setArrayFiller(ArrayFiller);
5691 if (InitializedFieldInUnion)
5692 CPLIE->setInitializedFieldInUnion(InitializedFieldInUnion);
5694 S.
Diag(Kind.getLocation(),
5695 diag::warn_cxx17_compat_aggregate_init_paren_list)
5696 << Kind.getLocation() << SR << ResultType;
5708 bool TopLevelOfInitList) {
5709 assert(!DestType->
isReferenceType() &&
"References are handled elsewhere");
5712 "Must have a class type to perform a user-defined conversion");
5722 bool AllowExplicit = Kind.AllowExplicit();
5728 = cast<CXXRecordDecl>(DestRecordType->getDecl());
5734 if (!Info.Constructor)
5737 if (!Info.Constructor->isInvalidDecl() &&
5738 Info.Constructor->isConvertingConstructor(
true)) {
5739 if (Info.ConstructorTmpl)
5741 Info.ConstructorTmpl, Info.FoundDecl,
5744 false, AllowExplicit);
5749 false, AllowExplicit);
5765 = cast<CXXRecordDecl>(SourceRecordType->getDecl());
5767 const auto &Conversions =
5769 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
5772 if (isa<UsingShadowDecl>(D))
5773 D = cast<UsingShadowDecl>(D)->getTargetDecl();
5780 Conv = cast<CXXConversionDecl>(D);
5784 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
5785 CandidateSet, AllowExplicit, AllowExplicit);
5788 DestType, CandidateSet, AllowExplicit,
5814 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
5816 if (isa<CXXConstructorDecl>(
Function)) {
5822 HadMultipleCandidates);
5851 HadMultipleCandidates);
5864 Function->getReturnType()->isReferenceType() ||
5874 if (Best->FinalConversion.First || Best->FinalConversion.Second ||
5875 Best->FinalConversion.Third) {
5878 ICS.
Standard = Best->FinalConversion;
5896 isa<CXXBoolLiteralExpr>(
Init) &&
5897 !cast<CXXBoolLiteralExpr>(
Init)->getValue() &&
5906 bool isAddressOf,
bool &isWeakAccess) {
5912 if (op->getOpcode() == UO_AddrOf)
5917 }
else if (
CastExpr *ce = dyn_cast<CastExpr>(e)) {
5918 switch (ce->getCastKind()) {
5921 case CK_LValueBitCast:
5925 case CK_ArrayToPointerDecay:
5928 case CK_NullToPointer:
5936 }
else if (isa<DeclRefExpr>(e)) {
5940 isWeakAccess =
true;
5944 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
5958 }
else if (isa<ArraySubscriptExpr>(e)) {
5974 bool isWeakAccess =
false;
5978 if (S.
getLangOpts().ObjCAutoRefCount && isWeakAccess)
6010 bool ArrayDecay =
false;
6015 ArgPointee = ArgArrayType->getElementType();
6027 bool ShouldCopy =
true;
6098 "cl_intel_device_side_avc_motion_estimation", S.
getLangOpts()) &&
6100 if (DestType->isOCLIntelSubgroupAVCMcePayloadType() ||
6101 DestType->isOCLIntelSubgroupAVCMceResultType())
6115 MultiExprArg Args,
bool TopLevelOfInitList,
bool TreatUnavailableAsInvalid)
6119 TreatUnavailableAsInvalid);
6125 auto *DRE = dyn_cast<DeclRefExpr>(E);
6126 if (!DRE || !isa<FunctionDecl>(DRE->getDecl()))
6130 cast<FunctionDecl>(DRE->getDecl()));
6147 return isa<DecompositionDecl>(Entity.
getDecl());
6173 bool TopLevelOfInitList,
6174 bool TreatUnavailableAsInvalid) {
6181 for (
unsigned I = 0, E = Args.size(); I != E; ++I)
6182 if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
6189 Args[I] = result.
get();
6211 if (Args.size() == 1) {
6229 TreatUnavailableAsInvalid);
6241 if (Args.size() != 1)
6247 else if (isa<InitListExpr>(Args[0]))
6251 TopLevelOfInitList);
6277 if (
Initializer && isa<VariableArrayType>(DestAT)) {
6309 if (
Initializer && isa<ConstantArrayType>(DestAT) &&
6327 Expr *OVEAsExpr = &OVE;
6329 TreatUnavailableAsInvalid);
6339 isa<CompoundLiteralExpr>(
Initializer->IgnoreParens()) &&
6357 *
this, TreatUnavailableAsInvalid);
6359 }
else if (S.
getLangOpts().CPlusPlus20 && !TopLevelOfInitList &&
6375 bool allowObjCWritebackConversion = S.
getLangOpts().ObjCAutoRefCount &&
6384 assert(
Initializer &&
"Initializer must be non-null");
6386 if (allowObjCWritebackConversion &&
6412 SourceType, DestType))))) {
6419 if (
const auto *RD =
6424 S.
getLangOpts().CPlusPlus20 && RD && RD->hasDefinition() &&
6425 RD->isAggregate() &&
Failed() &&
6438 S, Kind.getLocation(), Best);
6456 assert(
Initializer &&
"Initializer must be non-null");
6458 TopLevelOfInitList);
6463 assert(Args.size() >= 1 &&
"Zero-argument case handled above");
6473 for (
auto *Arg : Args) {
6474 if (Arg->getType()->isExtVectorType()) {
6477 for (
unsigned Idx = 0; Idx < Elm; ++Idx) {
6483 VTy->getElementType(), Arg->
getValueKind(), Arg->getObjectKind(),
6487 InitArgs.emplace_back(Arg);
6497 if (Args.size() > 1) {
6500 }
else if (isa<InitListExpr>(Args[0])) {
6508 assert(
Initializer &&
"Initializer must be non-null");
6511 bool NeedAtomicConversion =
false;
6515 Atomic->getValueType())) {
6516 DestType =
Atomic->getValueType();
6517 NeedAtomicConversion =
true;
6522 TopLevelOfInitList);
6524 if (!
Failed() && NeedAtomicConversion)
6551 Sema::AllowedExplicit::None,
6553 Kind.isCStyleOrFunctionalCast(),
6554 allowObjCWritebackConversion);
6562 bool ShouldCopy =
true;
6578 }
else if (ICS.
isBad()) {
6586 else if (
Initializer->getType()->isFunctionType() &&
6599 for (
auto &S : Steps)
6657 llvm_unreachable(
"Invalid EntityKind!");
6691 llvm_unreachable(
"missed an InitializedEntity kind?");
6725 llvm_unreachable(
"missed an InitializedEntity kind?");
6764 llvm_unreachable(
"missed an InitializedEntity kind?");
6791 bool IsExtraneousCopy) {
6816 S, Loc, CurInitExpr, CandidateSet,
T, Ctors, Best,
6828 ? diag::ext_rvalue_to_reference_temp_copy_no_viable
6829 : diag::err_temp_copy_no_viable)
6847 S.
Diag(Loc, diag::err_temp_copy_deleted)
6854 bool HadMultipleCandidates = CandidateSet.
size() > 1;
6863 if (IsExtraneousCopy) {
6874 for (
unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
6877 diag::err_call_incomplete_argument))
6918 Best->Function->getParamDecl(0)->getType().getNonReferenceType(),
6923 Loc,
T, Best->FoundDecl, Constructor, Elidable, ConstructorArgs,
6924 HadMultipleCandidates,
6940 Expr *CurInitExpr) {
6959 S, Loc, CurInitExpr, CandidateSet, CurInitExpr->
getType(), Ctors, Best,
6972 Best->FoundDecl, Entity,
Diag);
6993void InitializationSequence::PrintInitLocationNote(
Sema &S,
7008 diag::note_method_return_type_change)
7026 switch (Kind.getKind()) {
7032 return NumArgs != 1;
7044 bool &ConstructorInitRequiresZeroInit,
7045 bool IsListInitialization,
7046 bool IsStdInitListInitialization,
7049 unsigned NumArgs = Args.size();
7056 SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
7057 ? Kind.getEqualLoc()
7058 : Kind.getLocation();
7064 assert(Constructor->getParent() &&
"No parent class for constructor.");
7065 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
7066 Constructor->isTrivial() && !Constructor->isUsed(
false)) {
7081 bool AllowExplicitConv =
7082 Kind.AllowExplicit() && !Kind.isCopyInit() && Args.size() == 1 &&
7087 if (NumArgs == 1 && !Kind.isExplicitCast())
7089 Entity.
getType(), Args.front()->getType(), Kind.getLocation());
7094 ConstructorArgs, AllowExplicitConv,
7095 IsListInitialization))
7109 : Kind.getParenOrBraceRange();
7112 if (
auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(
7122 ConstructorArgs, ParenOrBraceRange, HadMultipleCandidates,
7123 IsListInitialization, IsStdInitListInitialization,
7124 ConstructorInitRequiresZeroInit),
7140 if (IsListInitialization)
7141 ParenOrBraceRange =
SourceRange(LBraceLoc, RBraceLoc);
7143 ParenOrBraceRange = Kind.getParenOrBraceRange();
7152 HadMultipleCandidates,
7153 IsListInitialization,
7154 IsStdInitListInitialization,
7155 ConstructorInitRequiresZeroInit,
7163 HadMultipleCandidates,
7164 IsListInitialization,
7165 IsStdInitListInitialization,
7166 ConstructorInitRequiresZeroInit,
7214using LifetimeResult =
7215 llvm::PointerIntPair<const InitializedEntity *, 3, LifetimeKind>;
7228 return {Entity, LK_Extended};
7248 : LK_MemInitializer};
7253 return {Entity, LK_Extended};
7260 return {
nullptr, LK_FullExpression};
7264 return {
nullptr, LK_FullExpression};
7270 return {
nullptr, LK_Return};
7275 return {
nullptr, LK_StmtExprResult};
7281 return {
nullptr, LK_New};
7289 return {
nullptr, LK_FullExpression};
7299 return {InitField, LK_MemInitializer};
7306 return {InitField, LK_MemInitializer};
7313 return {
nullptr, LK_FullExpression};
7317 return {
nullptr, LK_FullExpression};
7324 return {
nullptr, LK_FullExpression};
7327 llvm_unreachable(
"unknown entity kind");
7333 RK_ReferenceBinding,
7336 RK_StdInitializerList,
7349struct IndirectLocalPathEntry {
7363 const Decl *D =
nullptr;
7366 IndirectLocalPathEntry() {}
7367 IndirectLocalPathEntry(EntryKind K,
Expr *E) :
Kind(K), E(E) {}
7368 IndirectLocalPathEntry(EntryKind K,
Expr *E,
const Decl *D)
7369 :
Kind(K), E(E), D(D) {}
7376struct RevertToOldSizeRAII {
7377 IndirectLocalPath &Path;
7378 unsigned OldSize = Path.size();
7379 RevertToOldSizeRAII(IndirectLocalPath &Path) : Path(Path) {}
7380 ~RevertToOldSizeRAII() { Path.resize(OldSize); }
7383using LocalVisitor = llvm::function_ref<
bool(IndirectLocalPath &Path, Local L,
7389 if (E.Kind == IndirectLocalPathEntry::VarInit && E.D == VD)
7395 return llvm::any_of(Path, [=](IndirectLocalPathEntry E) {
7396 return E.Kind == IndirectLocalPathEntry::DefaultInit ||
7397 E.Kind == IndirectLocalPathEntry::VarInit;
7403 bool RevisitSubinits,
7404 bool EnableLifetimeWarnings);
7409 bool EnableLifetimeWarnings);
7424 if (
const auto *ND = dyn_cast<NamespaceDecl>(DC))
7426 StringRef Name = II->getName();
7427 if (Name.size() >= 2 && Name.front() ==
'_' &&
7436 if (
auto *Conv = dyn_cast_or_null<CXXConversionDecl>(Callee))
7437 if (isRecordWithAttr<PointerAttr>(Conv->getConversionType()))
7441 if (!isRecordWithAttr<PointerAttr>(
7442 Callee->getFunctionObjectParameterType()) &&
7443 !isRecordWithAttr<OwnerAttr>(Callee->getFunctionObjectParameterType()))
7445 if (Callee->getReturnType()->isPointerType() ||
7446 isRecordWithAttr<PointerAttr>(Callee->getReturnType())) {
7447 if (!Callee->getIdentifier())
7449 return llvm::StringSwitch<bool>(Callee->getName())
7450 .Cases(
"begin",
"rbegin",
"cbegin",
"crbegin",
true)
7451 .Cases(
"end",
"rend",
"cend",
"crend",
true)
7452 .Cases(
"c_str",
"data",
"get",
true)
7454 .Cases(
"find",
"equal_range",
"lower_bound",
"upper_bound",
true)
7456 }
else if (Callee->getReturnType()->isReferenceType()) {
7457 if (!Callee->getIdentifier()) {
7458 auto OO = Callee->getOverloadedOperator();
7459 return OO == OverloadedOperatorKind::OO_Subscript ||
7460 OO == OverloadedOperatorKind::OO_Star;
7462 return llvm::StringSwitch<bool>(Callee->getName())
7463 .Cases(
"front",
"back",
"at",
"top",
"value",
true)
7480 return llvm::StringSwitch<bool>(FD->
getName())
7481 .Cases(
"begin",
"rbegin",
"cbegin",
"crbegin",
true)
7482 .Cases(
"end",
"rend",
"cend",
"crend",
true)
7486 return llvm::StringSwitch<bool>(FD->
getName())
7487 .Cases(
"get",
"any_cast",
true)
7494 LocalVisitor Visit) {
7495 auto VisitPointerArg = [&](
const Decl *D,
Expr *Arg,
bool Value) {
7498 if (isa<MemberExpr>(Arg->IgnoreImpCasts()))
7502 for (
const IndirectLocalPathEntry &PE : llvm::reverse(Path)) {
7503 if (PE.Kind == IndirectLocalPathEntry::GslReferenceInit)
7505 if (PE.Kind == IndirectLocalPathEntry::GslPointerInit)
7510 Path.push_back({
Value ? IndirectLocalPathEntry::GslPointerInit
7511 : IndirectLocalPathEntry::GslReferenceInit,
7513 if (Arg->isGLValue())
7523 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(
Call)) {
7524 const auto *MD = cast_or_null<CXXMethodDecl>(MCE->getDirectCallee());
7526 VisitPointerArg(MD, MCE->getImplicitObjectArgument(),
7527 !MD->getReturnType()->isReferenceType());
7529 }
else if (
auto *OCE = dyn_cast<CXXOperatorCallExpr>(
Call)) {
7531 if (Callee && Callee->isCXXInstanceMember() &&
7533 VisitPointerArg(Callee, OCE->getArg(0),
7534 !Callee->getReturnType()->isReferenceType());
7536 }
else if (
auto *CE = dyn_cast<CallExpr>(
Call)) {
7539 VisitPointerArg(Callee, CE->getArg(0),
7540 !Callee->getReturnType()->isReferenceType());
7544 if (
auto *CCE = dyn_cast<CXXConstructExpr>(
Call)) {
7545 const auto *Ctor = CCE->getConstructor();
7547 if (CCE->getNumArgs() > 0 && RD->
hasAttr<PointerAttr>())
7548 VisitPointerArg(Ctor->getParamDecl(0), CCE->getArgs()[0],
true);
7576 auto *MD = dyn_cast<CXXMethodDecl>(FD);
7577 if (MD && MD->isCXXInstanceMember())
7580 LHST = MD->getParamDecl(0)->getType();
7590 LocalVisitor Visit) {
7594 if (
auto *CE = dyn_cast<CallExpr>(
Call)) {
7595 Callee = CE->getDirectCallee();
7598 auto *CCE = cast<CXXConstructExpr>(
Call);
7599 Callee = CCE->getConstructor();
7605 Expr *ObjectArg =
nullptr;
7606 if (isa<CXXOperatorCallExpr>(
Call) && Callee->isCXXInstanceMember()) {
7607 ObjectArg = Args[0];
7608 Args = Args.slice(1);
7609 }
else if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(
Call)) {
7610 ObjectArg = MCE->getImplicitObjectArgument();
7613 auto VisitLifetimeBoundArg = [&](
const Decl *D,
Expr *Arg) {
7614 Path.push_back({IndirectLocalPathEntry::LifetimeBoundCall, Arg, D});
7615 if (Arg->isGLValue())
7625 bool CheckCoroCall =
false;
7626 if (
const auto *RD = Callee->getReturnType()->getAsRecordDecl()) {
7627 CheckCoroCall = RD->
hasAttr<CoroLifetimeBoundAttr>() &&
7628 RD->
hasAttr<CoroReturnTypeAttr>() &&
7629 !Callee->hasAttr<CoroDisableLifetimeBoundAttr>();
7633 bool CheckCoroObjArg = CheckCoroCall;
7635 if (
auto *LE = dyn_cast<LambdaExpr>(ObjectArg->
IgnoreImplicit());
7636 LE && LE->captures().empty())
7637 CheckCoroObjArg =
false;
7641 CheckCoroObjArg =
false;
7643 VisitLifetimeBoundArg(Callee, ObjectArg);
7646 for (
unsigned I = 0,
7647 N = std::min<unsigned>(Callee->getNumParams(), Args.size());
7649 if (CheckCoroCall || Callee->getParamDecl(I)->hasAttr<LifetimeBoundAttr>())
7650 VisitLifetimeBoundArg(Callee->getParamDecl(I), Args[I]);
7659 bool EnableLifetimeWarnings) {
7660 RevertToOldSizeRAII RAII(Path);
7667 if (
auto *FE = dyn_cast<FullExpr>(
Init))
7668 Init = FE->getSubExpr();
7678 Init =
const_cast<Expr *
>(
Init->skipRValueSubobjectAdjustments());
7683 if (CE->getSubExpr()->isGLValue())
7684 Init = CE->getSubExpr();
7688 if (
auto *ASE = dyn_cast<ArraySubscriptExpr>(
Init)) {
7689 Init = ASE->getBase();
7690 auto *ICE = dyn_cast<ImplicitCastExpr>(
Init);
7691 if (ICE && ICE->getCastKind() == CK_ArrayToPointerDecay)
7692 Init = ICE->getSubExpr();
7697 EnableLifetimeWarnings);
7702 if (
auto *DIE = dyn_cast<CXXDefaultInitExpr>(
Init)) {
7704 {IndirectLocalPathEntry::DefaultInit, DIE, DIE->getField()});
7705 Init = DIE->getExpr();
7707 }
while (
Init != Old);
7709 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(
Init)) {
7710 if (Visit(Path, Local(MTE), RK))
7712 EnableLifetimeWarnings);
7715 if (isa<CallExpr>(
Init)) {
7716 if (EnableLifetimeWarnings)
7721 switch (
Init->getStmtClass()) {
7722 case Stmt::DeclRefExprClass: {
7725 auto *DRE = cast<DeclRefExpr>(
Init);
7726 auto *VD = dyn_cast<VarDecl>(DRE->getDecl());
7727 if (VD && VD->hasLocalStorage() &&
7728 !DRE->refersToEnclosingVariableOrCapture()) {
7730 Visit(Path, Local(DRE), RK);
7731 }
else if (isa<ParmVarDecl>(DRE->getDecl())) {
7735 }
else if (VD->getInit() && !
isVarOnPath(Path, VD)) {
7736 Path.push_back({IndirectLocalPathEntry::VarInit, DRE, VD});
7738 RK_ReferenceBinding, Visit,
7739 EnableLifetimeWarnings);
7745 case Stmt::UnaryOperatorClass: {
7750 if (
U->getOpcode() == UO_Deref)
7752 EnableLifetimeWarnings);
7756 case Stmt::ArraySectionExprClass: {
7758 cast<ArraySectionExpr>(
Init)->getBase(),
7759 Visit,
true, EnableLifetimeWarnings);
7763 case Stmt::ConditionalOperatorClass:
7764 case Stmt::BinaryConditionalOperatorClass: {
7765 auto *
C = cast<AbstractConditionalOperator>(
Init);
7766 if (!
C->getTrueExpr()->getType()->isVoidType())
7768 EnableLifetimeWarnings);
7769 if (!
C->getFalseExpr()->getType()->isVoidType())
7771 EnableLifetimeWarnings);
7775 case Stmt::CompoundLiteralExprClass: {
7776 if (
auto *CLE = dyn_cast<CompoundLiteralExpr>(
Init)) {
7777 if (!CLE->isFileScope())
7778 Visit(Path, Local(CLE), RK);
7794 bool RevisitSubinits,
7795 bool EnableLifetimeWarnings) {
7796 RevertToOldSizeRAII RAII(Path);
7804 if (
auto *DIE = dyn_cast<CXXDefaultInitExpr>(
Init)) {
7805 Path.push_back({IndirectLocalPathEntry::DefaultInit, DIE, DIE->getField()});
7806 Init = DIE->getExpr();
7809 if (
auto *FE = dyn_cast<FullExpr>(
Init))
7810 Init = FE->getSubExpr();
7813 Init =
const_cast<Expr *
>(
Init->skipRValueSubobjectAdjustments());
7816 Init = BTE->getSubExpr();
7821 if (
auto *CE = dyn_cast<CastExpr>(
Init)) {
7822 switch (CE->getCastKind()) {
7823 case CK_LValueToRValue:
7826 Path.push_back({IndirectLocalPathEntry::LValToRVal, CE});
7828 Path,
Init, RK_ReferenceBinding,
7829 [&](IndirectLocalPath &Path, Local L, ReferenceKind RK) ->
bool {
7830 if (
auto *DRE = dyn_cast<DeclRefExpr>(L)) {
7831 auto *VD = dyn_cast<VarDecl>(DRE->getDecl());
7834 Path.push_back({IndirectLocalPathEntry::VarInit, DRE, VD});
7836 EnableLifetimeWarnings);
7838 }
else if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(L)) {
7839 if (MTE->getType().isConstQualified())
7841 true, EnableLifetimeWarnings);
7844 }, EnableLifetimeWarnings);
7852 case CK_BaseToDerived:
7853 case CK_DerivedToBase:
7854 case CK_UncheckedDerivedToBase:
7857 case CK_UserDefinedConversion:
7858 case CK_ConstructorConversion:
7859 case CK_IntegralToPointer:
7860 case CK_PointerToIntegral:
7861 case CK_VectorSplat:
7862 case CK_IntegralCast:
7863 case CK_CPointerToObjCPointerCast:
7864 case CK_BlockPointerToObjCPointerCast:
7865 case CK_AnyPointerToBlockPointerCast:
7866 case CK_AddressSpaceConversion:
7869 case CK_ArrayToPointerDecay:
7872 Path.push_back({IndirectLocalPathEntry::AddressOf, CE});
7874 RK_ReferenceBinding, Visit,
7875 EnableLifetimeWarnings);
7881 Init = CE->getSubExpr();
7883 }
while (Old !=
Init);
7888 if (
auto *ILE = dyn_cast<CXXStdInitializerListExpr>(
Init))
7890 RK_StdInitializerList, Visit,
7891 EnableLifetimeWarnings);
7897 if (!RevisitSubinits)
7903 EnableLifetimeWarnings);
7906 for (
unsigned I = 0, N = ILE->
getNumInits(); I != N; ++I)
7909 EnableLifetimeWarnings);
7914 assert(RD->isAggregate() &&
"aggregate init on non-aggregate");
7922 RK_ReferenceBinding, Visit,
7923 EnableLifetimeWarnings);
7926 for (; Index < RD->getNumBases() && Index < ILE->getNumInits(); ++Index)
7929 EnableLifetimeWarnings);
7930 for (
const auto *I : RD->
fields()) {
7933 if (I->isUnnamedBitField())
7936 if (I->getType()->isReferenceType())
7938 RK_ReferenceBinding, Visit,
7939 EnableLifetimeWarnings);
7946 EnableLifetimeWarnings);
7956 if (
auto *LE = dyn_cast<LambdaExpr>(
Init)) {
7958 for (
Expr *E : LE->capture_inits()) {
7959 assert(CapI != LE->capture_end());
7964 Path.push_back({IndirectLocalPathEntry::LambdaCaptureInit, E, &Cap});
7967 Visit, EnableLifetimeWarnings);
7970 EnableLifetimeWarnings);
7978 if (
auto *CCE = dyn_cast<CXXConstructExpr>(
Init)) {
7979 if (CCE->getConstructor()->isCopyOrMoveConstructor()) {
7980 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(CCE->getArg(0))) {
7981 Expr *Arg = MTE->getSubExpr();
7982 Path.push_back({IndirectLocalPathEntry::TemporaryCopy, Arg,
7983 CCE->getConstructor()});
7991 if (isa<CallExpr>(
Init) || isa<CXXConstructExpr>(
Init)) {
7992 if (EnableLifetimeWarnings)
7997 switch (
Init->getStmtClass()) {
7998 case Stmt::UnaryOperatorClass: {
7999 auto *UO = cast<UnaryOperator>(
Init);
8002 if (UO->getOpcode() == UO_AddrOf) {
8006 if (isa<MaterializeTemporaryExpr>(UO->getSubExpr()))
8009 Path.push_back({IndirectLocalPathEntry::AddressOf, UO});
8011 RK_ReferenceBinding, Visit,
8012 EnableLifetimeWarnings);
8017 case Stmt::BinaryOperatorClass: {
8019 auto *BO = cast<BinaryOperator>(
Init);
8021 if (!BO->getType()->isPointerType() || (BOK != BO_Add && BOK != BO_Sub))
8024 if (BO->getLHS()->getType()->isPointerType())
8026 EnableLifetimeWarnings);
8027 else if (BO->getRHS()->getType()->isPointerType())
8029 EnableLifetimeWarnings);
8033 case Stmt::ConditionalOperatorClass:
8034 case Stmt::BinaryConditionalOperatorClass: {
8035 auto *
C = cast<AbstractConditionalOperator>(
Init);
8038 if (!
C->getTrueExpr()->getType()->isVoidType())
8040 EnableLifetimeWarnings);
8041 if (!
C->getFalseExpr()->getType()->isVoidType())
8043 EnableLifetimeWarnings);
8047 case Stmt::BlockExprClass:
8048 if (cast<BlockExpr>(
Init)->getBlockDecl()->hasCaptures()) {
8050 Visit(Path, Local(cast<BlockExpr>(
Init)), RK_ReferenceBinding);
8054 case Stmt::AddrLabelExprClass:
8056 Visit(Path, Local(cast<AddrLabelExpr>(
Init)), RK_ReferenceBinding);
8082 for (
auto Elem : Path) {
8083 if (Elem.Kind == IndirectLocalPathEntry::DefaultInit)
8084 Kind = PathLifetimeKind::ShouldExtend;
8085 else if (Elem.Kind != IndirectLocalPathEntry::LambdaCaptureInit)
8086 return PathLifetimeKind::NoExtend;
8094 for (
unsigned N = Path.size(); I != N; ++I) {
8095 switch (Path[I].Kind) {
8096 case IndirectLocalPathEntry::AddressOf:
8097 case IndirectLocalPathEntry::LValToRVal:
8098 case IndirectLocalPathEntry::LifetimeBoundCall:
8099 case IndirectLocalPathEntry::TemporaryCopy:
8100 case IndirectLocalPathEntry::GslReferenceInit:
8101 case IndirectLocalPathEntry::GslPointerInit:
8106 case IndirectLocalPathEntry::VarInit:
8107 if (cast<VarDecl>(Path[I].D)->isImplicit())
8110 case IndirectLocalPathEntry::DefaultInit:
8111 return Path[I].E->getSourceRange();
8113 case IndirectLocalPathEntry::LambdaCaptureInit:
8114 if (!Path[I].
Capture->capturesVariable())
8116 return Path[I].E->getSourceRange();
8123 for (
const auto &It : llvm::reverse(Path)) {
8124 if (It.Kind == IndirectLocalPathEntry::VarInit)
8126 if (It.Kind == IndirectLocalPathEntry::AddressOf)
8128 if (It.Kind == IndirectLocalPathEntry::LifetimeBoundCall)
8130 return It.Kind == IndirectLocalPathEntry::GslPointerInit ||
8131 It.Kind == IndirectLocalPathEntry::GslReferenceInit;
8139 LifetimeKind LK = LR.getInt();
8144 if (LK == LK_FullExpression)
8147 auto TemporaryVisitor = [&](IndirectLocalPath &Path, Local L,
8148 ReferenceKind RK) ->
bool {
8152 auto *MTE = dyn_cast<MaterializeTemporaryExpr>(L);
8154 bool IsGslPtrInitWithGslTempOwner =
false;
8155 bool IsLocalGslOwner =
false;
8157 if (isa<DeclRefExpr>(L)) {
8163 IsLocalGslOwner = isRecordWithAttr<OwnerAttr>(L->getType());
8167 IsGslPtrInitWithGslTempOwner = MTE && !MTE->getExtendingDecl() &&
8168 isRecordWithAttr<OwnerAttr>(MTE->getType());
8172 if (!IsGslPtrInitWithGslTempOwner)
8178 case LK_FullExpression:
8179 llvm_unreachable(
"already handled this");
8191 if (IsGslPtrInitWithGslTempOwner && DiagLoc.
isValid()) {
8192 Diag(DiagLoc, diag::warn_dangling_lifetime_pointer) << DiagRange;
8197 case PathLifetimeKind::Extend:
8200 MTE->setExtendingDecl(ExtendingEntity->
getDecl(),
8205 case PathLifetimeKind::ShouldExtend:
8212 Diag(DiagLoc, diag::warn_unsupported_lifetime_extension)
8216 case PathLifetimeKind::NoExtend:
8223 Diag(DiagLoc, diag::warn_dangling_variable)
8226 << ExtendingEntity->
getDecl() <<
Init->isGLValue() << DiagRange;
8232 case LK_MemInitializer: {
8233 if (isa<MaterializeTemporaryExpr>(L)) {
8237 if (
auto *ExtendingDecl =
8238 ExtendingEntity ? ExtendingEntity->
getDecl() :
nullptr) {
8239 if (IsGslPtrInitWithGslTempOwner) {
8240 Diag(DiagLoc, diag::warn_dangling_lifetime_pointer_member)
8241 << ExtendingDecl << DiagRange;
8242 Diag(ExtendingDecl->getLocation(),
8243 diag::note_ref_or_ptr_member_declared_here)
8247 bool IsSubobjectMember = ExtendingEntity != &Entity;
8249 PathLifetimeKind::NoExtend
8250 ? diag::err_dangling_member
8251 : diag::warn_dangling_member)
8252 << ExtendingDecl << IsSubobjectMember << RK << DiagRange;
8257 Path.back().Kind != IndirectLocalPathEntry::DefaultInit) {
8258 Diag(ExtendingDecl->getLocation(),
8259 diag::note_lifetime_extending_member_declared_here)
8260 << RK << IsSubobjectMember;
8283 auto *DRE = dyn_cast<DeclRefExpr>(L);
8284 auto *VD = DRE ? dyn_cast<VarDecl>(DRE->getDecl()) :
nullptr;
8292 ExtendingEntity ? ExtendingEntity->
getDecl() :
nullptr) {
8293 bool IsPointer = !
Member->getType()->isReferenceType();
8294 Diag(DiagLoc, IsPointer ? diag::warn_init_ptr_member_to_parameter_addr
8295 : diag::warn_bind_ref_member_to_parameter)
8296 << Member << VD << isa<ParmVarDecl>(VD) << DiagRange;
8298 diag::note_ref_or_ptr_member_declared_here)
8306 if (isa<MaterializeTemporaryExpr>(L)) {
8307 if (IsGslPtrInitWithGslTempOwner)
8308 Diag(DiagLoc, diag::warn_dangling_lifetime_pointer) << DiagRange;
8310 Diag(DiagLoc, RK == RK_ReferenceBinding
8311 ? diag::warn_new_dangling_reference
8312 : diag::warn_new_dangling_initializer_list)
8321 case LK_StmtExprResult:
8322 if (
auto *DRE = dyn_cast<DeclRefExpr>(L)) {
8325 if (LK == LK_StmtExprResult)
8327 Diag(DiagLoc, diag::warn_ret_stack_addr_ref)
8329 << isa<ParmVarDecl>(DRE->getDecl()) << DiagRange;
8330 }
else if (isa<BlockExpr>(L)) {
8331 Diag(DiagLoc, diag::err_ret_local_block) << DiagRange;
8332 }
else if (isa<AddrLabelExpr>(L)) {
8335 if (LK == LK_StmtExprResult)
8337 Diag(DiagLoc, diag::warn_ret_addr_label) << DiagRange;
8338 }
else if (
auto *CLE = dyn_cast<CompoundLiteralExpr>(L)) {
8339 Diag(DiagLoc, diag::warn_ret_stack_addr_ref)
8343 Diag(DiagLoc, diag::warn_ret_local_temp_addr_ref)
8349 for (
unsigned I = 0; I != Path.size(); ++I) {
8350 auto Elem = Path[I];
8352 switch (Elem.Kind) {
8353 case IndirectLocalPathEntry::AddressOf:
8354 case IndirectLocalPathEntry::LValToRVal:
8359 case IndirectLocalPathEntry::LifetimeBoundCall:
8360 case IndirectLocalPathEntry::TemporaryCopy:
8361 case IndirectLocalPathEntry::GslPointerInit:
8362 case IndirectLocalPathEntry::GslReferenceInit:
8366 case IndirectLocalPathEntry::DefaultInit: {
8367 auto *FD = cast<FieldDecl>(Elem.D);
8368 Diag(FD->
getLocation(), diag::note_init_with_default_member_initializer)
8373 case IndirectLocalPathEntry::VarInit: {
8374 const VarDecl *VD = cast<VarDecl>(Elem.D);
8382 case IndirectLocalPathEntry::LambdaCaptureInit:
8383 if (!Elem.Capture->capturesVariable())
8387 const ValueDecl *VD = Elem.Capture->getCapturedVar();
8388 Diag(Elem.Capture->getLocation(), diag::note_lambda_capture_initializer)
8390 << (Elem.Capture->getCaptureKind() ==
LCK_ByRef) << VD
8404 if (
Init->isGLValue())
8407 EnableLifetimeWarnings);
8410 EnableLifetimeWarnings);
8417 const Expr *PostInit);
8424 bool IsReturnStmt) {
8435 unsigned DiagID = 0;
8465 if (VD->
hasAttr<BlocksAttr>())
8478 if (isa<ParmVarDecl>(VD))
8479 DiagID = diag::warn_redundant_move_on_return;
8481 DiagID = diag::warn_pessimizing_move_on_return;
8483 DiagID = diag::warn_pessimizing_move_on_initialization;
8525 if (UO->getOpcode() == UO_Deref &&
8526 UO->getSubExpr()->IgnoreParenCasts()->
8529 S.
PDiag(diag::warn_binding_null_to_reference)
8530 << UO->getSubExpr()->getSourceRange());
8536 bool BoundToLvalueReference) {
8549 Record.ForRangeLifetimeExtendTemps.push_back(MTE);
8581 if (!PointeeTy.isNull() &&
8582 PointeeTy.getAddressSpace() != ExprPointeeTy.getAddressSpace())
8583 CK = CK_AddressSpaceConversion;
8585 CK = CK_AddressSpaceConversion;
8600 if (!ZeroInitializationFixit.empty()) {
8602 const auto *VD = dyn_cast_or_null<VarDecl>(D);
8608 if (!DestType->
isRecordType() && VD && VD->isConstexpr()) {
8610 S.
Diag(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)
8613 ZeroInitializationFixit);
8615 unsigned DiagID = diag::err_default_init_const;
8617 DiagID = diag::ext_default_init_const;
8619 S.
Diag(Kind.getLocation(), DiagID)
8622 ZeroInitializationFixit);
8642 if (isa<InitListExpr>((
Expr *)Args[0])) {
8646 if (
auto *DD = dyn_cast_or_null<DeclaratorDecl>(Entity.
getDecl())) {
8648 TypeLoc TL = TInfo->getTypeLoc();
8651 Brackets = ArrayLoc.getBracketsRange();
8658 ArrayT->getSizeModifier(),
8659 ArrayT->getIndexTypeCVRQualifiers(),
8666 !Kind.isExplicitCast()) {
8668 SourceRange ParenRange = Kind.getParenOrBraceRange();
8673 Kind.isExplicitCast() ||
8683 Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
8689 S.
Diag(
Init->getBeginLoc(), diag::warn_cxx98_compat_reference_list_init)
8690 <<
Init->getSourceRange();
8693 if (S.
getLangOpts().MicrosoftExt && Args.size() == 1 &&
8699 S.
Diag(
Init->getBeginLoc(), diag::ext_init_from_predefined) <<
Init;
8710 S.
Diag(Args[0]->getBeginLoc(), diag::err_opencl_atomic_init)
8730 isa<InitListExpr>(Args[0]);
8731 (void)IsHLSLVectorInit;
8736 switch (Steps.front().Kind) {
8770 assert(Args.size() == 1 || IsHLSLVectorInit);
8789 CurInit.
get() && isa<InitListExpr>(CurInit.
get()));
8794 auto checkAbstractType = [&](
QualType T) ->
bool {
8799 diag::err_allocation_of_abstract_type);
8804 bool ConstructorInitRequiresZeroInit =
false;
8837 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
8849 CK_DerivedToBase, CurInit.
get(),
8865 if (
auto *DRE = dyn_cast<DeclRefExpr>(CurInit.
get()->
IgnoreParens())) {
8866 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
8879 assert(CurInit.
get()->
isPRValue() &&
"not a temporary");
8937 bool CreatedObject =
false;
8953 Loc,
Step->
Type, FoundFn, Constructor, ConstructorArgs,
8954 HadMultipleCandidates,
8966 CastKind = CK_ConstructorConversion;
8967 CreatedObject =
true;
8977 HadMultipleCandidates);
8981 CastKind = CK_UserDefinedConversion;
8985 if (CreatedObject && checkAbstractType(CurInit.
get()->
getType()))
9006 S.
PDiag(diag::err_access_dtor_temp) <<
T);
9030 "function reference should be lvalue");
9036 assert(CurInit.
get()->
isPRValue() &&
"cannot convert glvalue to atomic");
9044 if (
const auto *FromPtrType =
9047 if (FromPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
9048 !ToPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
9051 if (!Kind.isStaticCast()) {
9053 diag::warn_noderef_to_dereferenceable_pointer)
9073 CurInit = CurInitExprRes;
9094 InitListChecker PerformInitList(S, InitEntity,
9095 InitList, Ty,
false,
9097 if (PerformInitList.HadError())
9105 if ((*ResultType)->isRValueReferenceType())
9107 else if ((*ResultType)->isLValueReferenceType())
9114 PerformInitList.getFullyStructuredList();
9118 : StructuredInitList;
9135 assert(Args.size() == 1 &&
"expected a single argument for list init");
9137 S.
Diag(InitList->
getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
9143 ConstructorInitRequiresZeroInit,
9152 CurInit = cast<InitListExpr>(CurInit.
get())->getInit(0);
9181 bool IsStdInitListInit =
9185 ? Kind.getParenOrBraceRange()
9188 S, UseTemporary ? TempEntity : Entity, Kind,
9190 ConstructorInitRequiresZeroInit,
9201 if (NextStep != StepEnd &&
9206 ConstructorInitRequiresZeroInit =
true;
9209 !Kind.isImplicitValueInit()) {
9213 Kind.getRange().getBegin());
9217 Kind.getRange().getEnd());
9246 CurInit = CurInitExprRes;
9261 S.
Diag(Kind.getLocation(), diag::err_c23_constexpr_pointer_not_null);
9268 InitialCurInit.
get(),
9271 PrintInitLocationNote(S, Entity);
9273 }
else if (Complained)
9274 PrintInitLocationNote(S, Entity);
9290 CK_ObjCObjectLValueCast,
9302 BaseExpr, Kind.getLocation(), IndexExpr, Kind.getLocation());
9303 ArrayLoopCommonExprs.push_back(BaseExpr);
9308 assert(!ArrayLoopCommonExprs.empty() &&
9309 "mismatched SK_ArrayLoopIndex and SK_ArrayLoopInit");
9310 Expr *Common = ArrayLoopCommonExprs.pop_back_val();
9319 S.
Diag(Kind.getLocation(), diag::ext_array_init_copy)
9333 IncompleteDest->getElementType(), ConstantSource->getSize(),
9343 S.
Diag(Kind.getLocation(), diag::ext_array_init_parens)
9363 diag::warn_cxx98_compat_initializer_list_init)
9398 "Sampler initialization on non-sampler type.");
9404 S.
Diag(Kind.getLocation(), diag::err_sampler_argument_required)
9408 auto Var = cast<VarDecl>(DRE->getDecl());
9411 if (!Var->hasGlobalStorage()) {
9423 if (!Var->getInit() || !isa<ImplicitCastExpr>(Var->getInit()))
9425 Init = cast<ImplicitCastExpr>(
const_cast<Expr*
>(
9426 Var->getInit()))->getSubExpr();
9427 SourceType =
Init->getType();
9434 if (!
Init->isConstantInitializer(S.
Context,
false))
9439 S.
Diag(Kind.getLocation(), diag::err_sampler_initializer_not_integer)
9447 const uint64_t SamplerValue =
Result.getLimitedValue();
9454 unsigned AddressingMode = (0x0E & SamplerValue) >> 1;
9455 unsigned FilterMode = (0x30 & SamplerValue) >> 4;
9456 if (FilterMode != 1 && FilterMode != 2 &&
9458 "cl_intel_device_side_avc_motion_estimation", S.
getLangOpts()))
9459 S.
Diag(Kind.getLocation(),
9460 diag::warn_sampler_initializer_invalid_bits)
9462 if (AddressingMode > 4)
9463 S.
Diag(Kind.getLocation(),
9464 diag::warn_sampler_initializer_invalid_bits)
9465 <<
"Addressing Mode";
9471 CK_IntToOCLSampler);
9477 "Wrong type for initialization of OpenCL opaque type.");
9480 CK_ZeroToOCLOpaqueType,
9488 if (CurInit.
get() && ResultType)
9509 cast<FieldDecl>(Entity.
getDecl())->isBitField())
9510 S.CheckBitFieldInitialization(Kind.getLocation(),
9525 S.
Diag(Loc, diag::err_reference_without_init)
9526 <<
T.getNonReferenceType();
9534 for (
const auto *FI : RD->
fields()) {
9535 if (FI->isUnnamedBitField())
9539 S.
Diag(Loc, diag::note_value_initialization_here) << RD;
9544 for (
const auto &BI : RD->
bases()) {
9546 S.
Diag(Loc, diag::note_value_initialization_here) << RD;
9581 if (fromDecl && destDecl && fromDecl->getDeclKind() == Decl::CXXRecord &&
9582 destDecl->getDeclKind() == Decl::CXXRecord &&
9583 !fromDecl->isInvalidDecl() && !destDecl->isInvalidDecl() &&
9584 !fromDecl->hasDefinition() &&
9587 S.
Diag(fromDecl->getLocation(), diag::note_forward_class_conversion)
9615 if (
auto *D = Entity.
getDecl())
9616 Loc = D->getLocation();
9617 S.
Diag(Loc, diag::note_in_reference_temporary_list_initializer) <<
T;
9621 InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
9624 assert(DiagnoseInitList.HadError() &&
9625 "Inconsistent init list check result.");
9638 if (Args.size() == 1) {
9639 auto *List = dyn_cast<InitListExpr>(Args[0]);
9640 if (List && List->getNumInits() == 1)
9641 OnlyArg = List->getInit(0);
9660 assert(Diagnosed &&
"couldn't find uninitialized reference to diagnose");
9663 S.
Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
9664 <<
SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
9667 S.
Diag(Kind.getLocation(), diag::err_list_init_in_parens)
9668 << 1 << Entity.
getType() << Args[0]->getSourceRange();
9672 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
9675 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
9678 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
9681 S.
Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
9684 S.
Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
9687 S.
Diag(Kind.getLocation(),
9688 diag::err_array_init_incompat_wide_string_into_wchar);
9691 S.
Diag(Kind.getLocation(),
9692 diag::err_array_init_plain_string_into_char8_t);
9693 S.
Diag(Args.front()->getBeginLoc(),
9694 diag::note_array_init_plain_string_into_char8_t)
9698 S.
Diag(Kind.getLocation(), diag::err_array_init_utf8_string_into_char)
9703 S.
Diag(Kind.getLocation(),
9705 ? diag::err_array_init_different_type
9706 : diag::err_array_init_non_constant_array))
9709 << Args[0]->getSourceRange();
9713 S.
Diag(Kind.getLocation(), diag::err_variable_object_no_init)
9714 << Args[0]->getSourceRange();
9727 auto *FD = cast<FunctionDecl>(cast<DeclRefExpr>(OnlyArg)->getDecl());
9735 switch (FailedOverloadResult) {
9742 ? (S.
PDiag(diag::err_typecheck_ambiguous_condition)
9743 << OnlyArg->
getType() << DestType
9744 << Args[0]->getSourceRange())
9745 : (S.
PDiag(diag::err_ref_init_ambiguous)
9746 << DestType << OnlyArg->
getType()
9747 << Args[0]->getSourceRange())),
9755 diag::err_typecheck_nonviable_condition_incomplete,
9756 OnlyArg->
getType(), Args[0]->getSourceRange()))
9757 S.
Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
9759 << OnlyArg->
getType() << Args[0]->getSourceRange()
9771 S.
Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
9773 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef())
9774 << Args[0]->getSourceRange();
9778 llvm_unreachable(
"Inconsistent overload resolution?");
9784 llvm_unreachable(
"Conversion did not fail!");
9789 if (isa<InitListExpr>(Args[0])) {
9790 S.
Diag(Kind.getLocation(),
9791 diag::err_lvalue_reference_bind_to_initlist)
9794 << Args[0]->getSourceRange();
9800 S.
Diag(Kind.getLocation(),
9802 ? diag::err_lvalue_reference_bind_to_temporary
9803 : diag::err_lvalue_reference_bind_to_unrelated)
9807 << Args[0]->getSourceRange();
9812 FieldDecl *BitField = Args[0]->getSourceBitField();
9813 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
9816 << (BitField !=
nullptr)
9817 << Args[0]->getSourceRange();
9824 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
9826 << Args[0]->getSourceRange();
9830 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_matrix_element)
9835 S.
Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
9837 << Args[0]->getSourceRange();
9841 S.
Diag(Kind.getLocation(), diag::err_reference_bind_temporary_addrspace)
9842 << DestType << Args[0]->getSourceRange();
9853 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
9854 << NonRefType << SourceType << 1
9855 << Args[0]->getSourceRange();
9857 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
9858 << NonRefType << SourceType << 0
9864 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
9865 << NonRefType << SourceType << 2
9866 << Args[0]->getSourceRange();
9871 S.
Diag(Kind.getLocation(), diag::err_reference_bind_failed)
9876 << Args[0]->getSourceRange();
9887 << Args[0]->getSourceRange();
9889 S.
Diag(Kind.getLocation(), PDiag);
9901 auto *InitList = dyn_cast<InitListExpr>(Args[0]);
9902 if (InitList && InitList->getNumInits() >= 1) {
9903 R =
SourceRange(InitList->getInit(0)->getEndLoc(), InitList->getEndLoc());
9905 assert(Args.size() > 1 &&
"Expected multiple initializers!");
9906 R =
SourceRange(Args.front()->getEndLoc(), Args.back()->getEndLoc());
9910 if (Kind.isCStyleOrFunctionalCast())
9911 S.
Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
9914 S.
Diag(Kind.getLocation(), diag::err_excess_initializers)
9920 S.
Diag(Kind.getLocation(), diag::err_list_init_in_parens)
9921 << 0 << Entity.
getType() << Args[0]->getSourceRange();
9925 S.
Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
9930 S.
Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
9931 << (DestType->
isRecordType()) << DestType << Args[0]->getSourceRange();
9939 SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
9942 assert(Args.size() == 1 &&
9943 "List construction from other than 1 argument.");
9950 switch (FailedOverloadResult) {
9954 S.
PDiag(diag::err_ovl_ambiguous_init)
9955 << DestType << ArgsRange),
9972 if (
auto Inherited = Constructor->getInheritedConstructor())
9973 InheritedFrom = Inherited.getShadowDecl()->getNominatedBaseClass();
9975 S.
Diag(Kind.getLocation(), diag::err_missing_default_ctor)
9976 << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
9988 S.
Diag(Kind.getLocation(), diag::err_missing_default_ctor)
9989 << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
9995 diag::note_member_declared_at);
10000 diag::note_previous_decl)
10008 Kind.getLocation(),
10009 S.
PDiag(diag::err_ovl_no_viable_function_in_init)
10010 << DestType << ArgsRange),
10019 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
10020 << DestType << ArgsRange;
10021 llvm_unreachable(
"Inconsistent overload resolution?");
10029 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
10030 << llvm::to_underlying(
10032 << DestType << ArgsRange;
10035 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
10036 << DestType << (Msg !=
nullptr)
10037 << (Msg ? Msg->
getString() : StringRef()) << ArgsRange;
10045 llvm_unreachable(
"Conversion did not fail!");
10057 S.
Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
10058 << (Constructor->getInheritedConstructor() ? 2 :
10059 Constructor->isImplicit() ? 1 : 0)
10065 }
else if (
const auto *VD = dyn_cast_if_present<VarDecl>(Entity.
getDecl());
10066 VD && VD->isConstexpr()) {
10067 S.
Diag(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)
10070 S.
Diag(Kind.getLocation(), diag::err_default_init_const)
10077 diag::err_init_incomplete_type);
10093 S.
Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
10094 << Args[0]->getSourceRange();
10099 assert(Ovl ==
OR_Success &&
"Inconsistent overload resolution");
10102 diag::note_explicit_ctor_deduction_guide_here) <<
false;
10113 S.
Diag(Kind.getLocation(), diag::err_designated_init_for_non_aggregate)
10118 PrintInitLocationNote(S, Entity);
10125 OS <<
"Failed sequence: ";
10128 OS <<
"too many initializers for reference";
10132 OS <<
"parenthesized list init for reference";
10136 OS <<
"array requires initializer list";
10140 OS <<
"address of unaddressable function was taken";
10144 OS <<
"array requires initializer list or string literal";
10148 OS <<
"array requires initializer list or wide string literal";
10152 OS <<
"narrow string into wide char array";
10156 OS <<
"wide string into char array";
10160 OS <<
"incompatible wide string into wide char array";
10164 OS <<
"plain string literal into char8_t array";
10168 OS <<
"u8 string literal into char array";
10172 OS <<
"array type mismatch";
10176 OS <<
"non-constant array initializer";
10180 OS <<
"address of overloaded function failed";
10184 OS <<
"overload resolution for reference initialization failed";
10188 OS <<
"non-const lvalue reference bound to temporary";
10192 OS <<
"non-const lvalue reference bound to bit-field";
10196 OS <<
"non-const lvalue reference bound to vector element";
10200 OS <<
"non-const lvalue reference bound to matrix element";
10204 OS <<
"non-const lvalue reference bound to unrelated type";
10208 OS <<
"rvalue reference bound to an lvalue";
10212 OS <<
"reference initialization drops qualifiers";
10216 OS <<
"reference with mismatching address space bound to temporary";
10220 OS <<
"reference initialization failed";
10224 OS <<
"conversion failed";
10228 OS <<
"conversion from property failed";
10232 OS <<
"too many initializers for scalar";
10236 OS <<
"parenthesized list init for reference";
10240 OS <<
"referencing binding to initializer list";
10244 OS <<
"initializer list for non-aggregate, non-scalar type";
10248 OS <<
"overloading failed for user-defined conversion";
10252 OS <<
"constructor overloading failed";
10256 OS <<
"default initialization of a const variable";
10260 OS <<
"initialization of incomplete type";
10264 OS <<
"list initialization checker failure";
10268 OS <<
"variable length array has an initializer";
10272 OS <<
"initializer expression isn't contextually valid";
10276 OS <<
"list constructor overloading failed";
10280 OS <<
"list copy initialization chose explicit constructor";
10284 OS <<
"parenthesized list initialization failed";
10288 OS <<
"designated initializer for non-aggregate type";
10296 OS <<
"Dependent sequence\n";
10300 OS <<
"Normal sequence: ";
10311 OS <<
"resolve address of overloaded function";
10315 OS <<
"derived-to-base (prvalue)";
10319 OS <<
"derived-to-base (xvalue)";
10323 OS <<
"derived-to-base (lvalue)";
10327 OS <<
"bind reference to lvalue";
10331 OS <<
"bind reference to a temporary";
10335 OS <<
"final copy in class direct-initialization";
10339 OS <<
"extraneous C++03 copy to temporary";
10343 OS <<
"user-defined conversion via " << *S->Function.Function;
10347 OS <<
"qualification conversion (prvalue)";
10351 OS <<
"qualification conversion (xvalue)";
10355 OS <<
"qualification conversion (lvalue)";
10359 OS <<
"function reference conversion";
10363 OS <<
"non-atomic-to-atomic conversion";
10367 OS <<
"implicit conversion sequence (";
10373 OS <<
"implicit conversion sequence with narrowing prohibited (";
10379 OS <<
"list aggregate initialization";
10383 OS <<
"unwrap reference initializer list";
10387 OS <<
"rewrap reference initializer list";
10391 OS <<
"constructor initialization";
10395 OS <<
"list initialization via constructor";
10399 OS <<
"zero initialization";
10403 OS <<
"C assignment";
10407 OS <<
"string initialization";
10411 OS <<
"Objective-C object conversion";
10415 OS <<
"indexing for array initialization loop";
10419 OS <<
"array initialization loop";
10423 OS <<
"array initialization";
10427 OS <<
"array initialization (GNU extension)";
10431 OS <<
"parenthesized array initialization";
10435 OS <<
"pass by indirect copy and restore";
10439 OS <<
"pass by indirect restore";
10443 OS <<
"Objective-C object retension";
10447 OS <<
"std::initializer_list from initializer list";
10451 OS <<
"list initialization from std::initializer_list";
10455 OS <<
"OpenCL sampler_t from integer constant";
10459 OS <<
"OpenCL opaque type from zero";
10462 OS <<
"initialization from a parenthesized list of values";
10466 OS <<
" [" << S->Type <<
']';
10473 dump(llvm::errs());
10480 const Expr *PostInit) {
10496 auto MakeDiag = [&](
bool IsConstRef,
unsigned DefaultDiagID,
10497 unsigned ConstRefDiagID,
unsigned WarnDiagID) {
10500 if (L.CPlusPlus11 &&
10502 DiagID = IsConstRef ? ConstRefDiagID : DefaultDiagID;
10504 DiagID = WarnDiagID;
10524 MakeDiag(
T != EntityType, diag::ext_init_list_type_narrowing,
10525 diag::ext_init_list_type_narrowing_const_reference,
10526 diag::warn_init_list_type_narrowing)
10528 <<
T.getLocalUnqualifiedType();
10535 diag::ext_init_list_constant_narrowing,
10536 diag::ext_init_list_constant_narrowing_const_reference,
10537 diag::warn_init_list_constant_narrowing)
10546 diag::ext_init_list_variable_narrowing,
10547 diag::ext_init_list_variable_narrowing_const_reference,
10548 diag::warn_init_list_variable_narrowing)
10556 llvm::raw_svector_ostream OS(StaticCast);
10557 OS <<
"static_cast<";
10564 OS << *TT->getDecl();
10573 S.
Diag(PostInit->
getBeginLoc(), diag::note_init_list_narrowing_silence)
10584 Init->IgnoreParenImpCasts(), ToType,
false,
10585 Sema::AllowedExplicit::None,
10601 S.
Diag(
Init->getBeginLoc(), diag::err_c23_constexpr_init_not_representable)
10602 <<
Value.getAsString(S.
Context, PreNarrowingType) << ToType;
10607 S.
Diag(
Init->getBeginLoc(), diag::err_c23_constexpr_init_type_mismatch)
10608 << ToType << FromType;
10618 llvm_unreachable(
"unhandled case in switch");
10630 for (
unsigned I = 0, N = SE->
getLength(); I != N; ++I) {
10635 diag::err_c23_constexpr_init_not_representable)
10649 if (
Init.isInvalid())
10653 assert(InitE &&
"No initialization expression");
10658 return !
Seq.Failed();
10665 bool TopLevelOfInitList,
10666 bool AllowExplicit) {
10667 if (
Init.isInvalid())
10671 assert(InitE &&
"No initialization expression?");
10681 const bool ShouldTrackCopy =
10683 if (ShouldTrackCopy) {
10685 Seq.SetOverloadFailure(
10691 const auto LastStep =
Seq.step_end() - 1;
10692 assert(LastStep->Kind ==
10696 llvm::find_if(
Seq.getFailedCandidateSet(),
10698 return Candidate.Viable &&
10699 Candidate.Function == Function &&
10700 Candidate.Conversions.size() > 0;
10702 if (Candidate !=
Seq.getFailedCandidateSet().end() &&
10704 Candidate->
Viable =
false;
10708 Function->getParamDecl(0)->getType());
10716 if (ShouldTrackCopy)
10725 auto NotSpecialization = [&] (
const CXXRecordDecl *Candidate) {
10726 auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Candidate);
10729 return !(NotSpecialization(RD) && RD->
forallBases(NotSpecialization));
10735 auto *DeducedTST = dyn_cast<DeducedTemplateSpecializationType>(
10737 assert(DeducedTST &&
"not a deduced template specialization type");
10748 if (
auto *
AliasTemplate = dyn_cast_or_null<TypeAliasTemplateDecl>(
10750 Diag(Kind.getLocation(),
10751 diag::warn_cxx17_compat_ctad_for_alias_templates);
10754 ->getUnderlyingType()
10755 .getCanonicalType();
10759 if (
const auto *TST =
10761 Template = dyn_cast_or_null<ClassTemplateDecl>(
10762 TST->getTemplateName().getAsTemplateDecl());
10763 }
else if (
const auto *RT = UnderlyingType->getAs<
RecordType>()) {
10767 if (
const auto *CTSD = llvm::dyn_cast<ClassTemplateSpecializationDecl>(
10768 RT->getAsCXXRecordDecl()))
10769 Template = CTSD->getSpecializedTemplate();
10774 Diag(Kind.getLocation(),
10775 diag::err_deduced_non_class_or_alias_template_specialization_type)
10785 diag::warn_cxx14_compat_class_template_argument_deduction)
10815 ? dyn_cast<InitListExpr>(Inits[0])
10831 bool AllowExplicit = !Kind.isCopyInit() ||
ListInit;
10837 bool OnlyListConstructors,
10838 bool AllowAggregateDeductionCandidate) {
10844 if (!AllowExplicit) {
10851 if (GD->getMinRequiredArguments() > 1 ||
10852 (GD->getNumParams() == 0 && !GD->isVariadic()))
10862 if (!AllowAggregateDeductionCandidate &&
10878 bool SuppressUserConversions = Kind.isCopyInit();
10882 for (
Expr *E : Inits)
10883 if (
auto *DI = dyn_cast<DesignatedInitExpr>(E))
10884 TmpInits.push_back(DI->getInit());
10886 TmpInits.push_back(E);
10888 TD, FoundDecl,
nullptr, TmpInits, Candidates,
10889 SuppressUserConversions,
10890 false, AllowExplicit, ADLCallKind::NotADL,
10891 {}, AllowAggregateDeductionCandidate);
10894 SuppressUserConversions,
10895 false, AllowExplicit);
10899 bool FoundDeductionGuide =
false;
10901 auto TryToResolveOverload =
10904 bool HasAnyDeductionGuide =
false;
10907 auto *Pattern = Template;
10908 while (Pattern->getInstantiatedFromMemberTemplate()) {
10909 if (Pattern->isMemberSpecialization())
10911 Pattern = Pattern->getInstantiatedFromMemberTemplate();
10914 auto *RD = cast<CXXRecordDecl>(Pattern->getTemplatedDecl());
10920 InitListChecker CheckInitList(*
this, Entity,
ListInit, Ty, ElementTypes);
10921 if (!CheckInitList.HadError()) {
10930 for (
int I = 0, E =
ListInit->getNumInits();
10931 I < E && !isa<PackExpansionType>(ElementTypes[I]); ++I)
10932 if (ElementTypes[I]->isArrayType()) {
10933 if (isa<InitListExpr>(
ListInit->getInit(I)))
10935 else if (isa<StringLiteral>(
10936 ListInit->getInit(I)->IgnoreParenImpCasts()))
10943 LookupTemplateDecl, ElementTypes,
10947 OnlyListConstructors,
10949 HasAnyDeductionGuide =
true;
10954 for (
auto I = Guides.
begin(), E = Guides.
end(); I != E; ++I) {
10955 NamedDecl *D = (*I)->getUnderlyingDecl();
10959 auto *TD = dyn_cast<FunctionTemplateDecl>(D);
10960 auto *GD = dyn_cast_if_present<CXXDeductionGuideDecl>(
10965 if (!GD->isImplicit())
10966 HasAnyDeductionGuide =
true;
10968 addDeductionCandidate(TD, GD, I.getPair(), OnlyListConstructors,
10983 }
else if (Inits.size()) {
10988 Inits, Inits.back()->getEndLoc());
10989 SynthesizeAggrGuide(&TempListInit);
10993 FoundDeductionGuide = FoundDeductionGuide || HasAnyDeductionGuide;
11003 bool TryListConstructors =
true;
11009 auto *FD = dyn_cast<FunctionDecl>(D->getUnderlyingDecl());
11010 if (FD && FD->getMinRequiredArguments() == 0) {
11011 TryListConstructors =
false;
11015 }
else if (
ListInit->getNumInits() == 1) {
11023 if (!isa<InitListExpr>(E) && RD &&
11026 TryListConstructors =
false;
11029 if (TryListConstructors)
11030 Result = TryToResolveOverload(
true);
11039 Result = TryToResolveOverload(
false);
11048 Kind.getLocation(),
11049 PDiag(diag::err_deduced_class_template_ctor_ambiguous)
11056 cast<ClassTemplateDecl>(Template)->getTemplatedDecl();
11061 Kind.getLocation(),
11062 PDiag(
Complete ? diag::err_deduced_class_template_ctor_no_viable
11063 : diag::err_deduced_class_template_incomplete)
11073 Diag(Kind.getLocation(), diag::err_deduced_class_template_deleted)
11083 if (Kind.isCopyInit() &&
ListInit &&
11084 cast<CXXDeductionGuideDecl>(Best->Function)->isExplicit()) {
11085 bool IsDeductionGuide = !Best->Function->isImplicit();
11086 Diag(Kind.getLocation(), diag::err_deduced_class_template_explicit)
11088 Diag(Best->Function->getLocation(),
11089 diag::note_explicit_ctor_deduction_guide_here)
11090 << IsDeductionGuide;
11107 diag::warn_cxx14_compat_class_template_argument_deduction)
11112 if (!FoundDeductionGuide) {
11114 diag::warn_ctad_maybe_unsupported)
11116 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 implicitObjectParamIsLifetimeBound(const FunctionDecl *FD)
static bool isExprAnUnaddressableFunction(Sema &S, const Expr *E)
Tries to get a FunctionDecl out of E.
static bool shouldTrackImplicitObjectArg(const CXXMethodDecl *Callee)
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 visitLifetimeBoundArguments(IndirectLocalPath &Path, Expr *Call, LocalVisitor Visit)
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 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 handleGslAnnotatedTypes(IndirectLocalPath &Path, Expr *Call, LocalVisitor Visit)
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 pathOnlyInitializesGslPointer(IndirectLocalPath &Path)
static bool isInStlNamespace(const Decl *D)
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 PathLifetimeKind shouldLifetimeExtendThroughPath(const IndirectLocalPath &Path)
Determine whether this is an indirect path to a temporary that we are supposed to lifetime-extend alo...
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 LifetimeResult getEntityLifetime(const InitializedEntity *Entity, const InitializedEntity *InitField=nullptr)
Determine the declaration which an initialized entity ultimately refers to, for the purpose of lifeti...
static bool isVarOnPath(IndirectLocalPath &Path, VarDecl *VD)
static bool shouldTrackFirstArgument(const FunctionDecl *FD)
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 bool pathContainsInit(IndirectLocalPath &Path)
static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT, Sema &S, bool CheckC23ConstexprInit=false)
static bool isRecordWithAttr(QualType Type)
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...
PathLifetimeKind
Whether a path to an object supports lifetime extension.
@ ShouldExtend
We should lifetime-extend, but we don't because (due to technical limitations) we can't.
@ NoExtend
Do not lifetime extend along this path.
@ Extend
Lifetime-extend along this path.
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 SourceRange nextPathEntryRange(const IndirectLocalPath &Path, unsigned I, Expr *E)
Find the range for the first interesting entry in the path at or after I.
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 void visitLocalsRetainedByReferenceBinding(IndirectLocalPath &Path, Expr *Init, ReferenceKind RK, LocalVisitor Visit, bool EnableLifetimeWarnings)
Visit the locals that would be reachable through a reference bound to the glvalue expression Init.
static bool ResolveOverloadedFunctionForReferenceBinding(Sema &S, Expr *Initializer, QualType &SourceType, QualType &UnqualifiedSourceType, QualType UnqualifiedTargetType, InitializationSequence &Sequence)
static void visitLocalsRetainedByInitializer(IndirectLocalPath &Path, Expr *Init, LocalVisitor Visit, bool RevisitSubinits, bool EnableLifetimeWarnings)
Visit the locals that would be reachable through an object initialized by the prvalue expression Init...
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.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
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 getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
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.
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
Type source information for an attributed type.
TypeLoc getModifiedLoc() const
The modified type, which is generally canonically different from the attribute type.
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 binding an expression to a temporary.
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.
Represents a static or instance method of a struct/union/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.
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,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing 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 ...
bool isStdNamespace() const
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.
bool isInStdNamespace() const
SourceLocation getEndLoc() const LLVM_READONLY
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isInvalidDecl() const
SourceLocation getLocation() const
DeclContext * getDeclContext()
SourceLocation getBeginLoc() const LLVM_READONLY
The name of a declaration.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
SourceLocation getBeginLoc() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Represents a single C99 designator.
bool isFieldDesignator() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isArrayRangeDesignator() const
void setFieldDecl(FieldDecl *FD)
FieldDecl * getFieldDecl() const
bool isArrayDesignator() const
SourceLocation getFieldLoc() const
const IdentifierInfo * getFieldName() const
SourceLocation getDotLoc() const
SourceLocation getLBracketLoc() 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.
SourceLocation getFieldLoc() const
SourceLocation getDotLoc() const
Expr * getArrayRangeStart() const
bool isArrayDesignator() const
SourceLocation getLBracketLoc() const
bool isArrayRangeDesignator() const
bool isFieldDesignator() const
SourceLocation getRBracketLoc() const
SourceLocation getEllipsisLoc() const
Expr * getArrayRangeEnd() const
const IdentifierInfo * getFieldDecl() const
Expr * getArrayIndex() const
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.
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
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.
unsigned allocateManglingNumber() const
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.
bool isDefaultMemberInitializer() const
Is this the default member initializer of a member (specified inside the class definition)?
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].
Describes the capture of a variable or of this, or of a C++1y init-capture.
bool capturesVariable() const
Determine whether this capture handles a variable.
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.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
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.
QualType getEncodedType() const
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.
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)
bool CheckObjCBridgeRelatedConversions(SourceLocation Loc, QualType DestType, QualType SrcType, Expr *&SrcExpr, bool Diagnose=true)
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.
DiagnosticsEngine & getDiagnostics() const
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)
void EmitRelatedResultTypeNoteForReturn(QualType destType)
Given that we had incompatible pointer types in a return statement, check whether we're in a method w...
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...
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
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()
static bool CanBeGetReturnObject(const FunctionDecl *FD)
NamespaceDecl * getStdNamespace() const
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type,...
bool isObjCWritebackConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
Determine whether this is an Objective-C writeback conversion, used for parameter passing when perfor...
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 CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr, bool Diagnose=true)
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.
bool isValid() const
Return true if this is a valid SourceLocation object.
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...
const Type * getTypeForDecl() const
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.
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
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 ...
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
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)
The JSON file list parser is used to communicate input to InstallAPI.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
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.
bool isCompoundAssignmentOperator(OverloadedOperatorKind Kind)
Determine if this is a compound assignment operator.
@ ovl_fail_bad_conversion
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
LLVM_READONLY bool isUppercase(unsigned char c)
Return true if this character is an uppercase ASCII letter: [A-Z].
@ LCK_ByRef
Capturing by reference.
@ 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.