31#include "llvm/ADT/APInt.h"
32#include "llvm/ADT/FoldingSet.h"
33#include "llvm/ADT/PointerIntPair.h"
34#include "llvm/ADT/SmallString.h"
35#include "llvm/ADT/SmallVector.h"
36#include "llvm/ADT/StringExtras.h"
37#include "llvm/Support/ErrorHandling.h"
38#include "llvm/Support/raw_ostream.h"
74 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
92 auto IsCharOrUnsignedChar = [](
const QualType &T) {
93 const BuiltinType *BT = dyn_cast<BuiltinType>(T.getTypePtr());
98 case StringLiteralKind::UTF8:
108 case StringLiteralKind::Ordinary:
112 return (SL->
getKind() == StringLiteralKind::UTF8 &&
126 case StringLiteralKind::UTF16:
134 case StringLiteralKind::UTF32:
142 case StringLiteralKind::Wide:
150 case StringLiteralKind::Unevaluated:
151 assert(
false &&
"Unevaluated string literal in initialization");
155 llvm_unreachable(
"missed a StringLiteral kind?");
176 if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
187 if (isa<CompoundLiteralExpr>(E))
202 if (
const auto *VD = dyn_cast_if_present<VarDecl>(D); VD && VD->isConstexpr())
212 Sema &S,
bool CheckC23ConstexprInit =
false) {
214 auto *ConstantArrayTy =
216 uint64_t StrLength = ConstantArrayTy->getSize().getZExtValue();
218 if (CheckC23ConstexprInit)
225 llvm::APInt ConstVal(32, StrLength);
249 if (StrLength > CAT->
getSize().getZExtValue())
251 diag::err_initializer_string_for_char_array_too_long)
252 << CAT->
getSize().getZExtValue() << StrLength
256 if (StrLength-1 > CAT->
getSize().getZExtValue())
258 diag::ext_initializer_string_for_char_array_too_long)
306class InitListChecker {
308 bool hadError =
false;
310 bool TreatUnavailableAsInvalid;
311 bool InOverloadResolution;
325 unsigned &StructuredIndex);
329 bool TopLevelObject =
false);
332 bool SubobjectIsDesignatorContext,
335 unsigned &StructuredIndex,
336 bool TopLevelObject =
false);
341 unsigned &StructuredIndex,
342 bool DirectlyDesignated =
false);
347 unsigned &StructuredIndex);
352 unsigned &StructuredIndex);
357 unsigned &StructuredIndex);
361 unsigned &StructuredIndex);
366 bool SubobjectIsDesignatorContext,
unsigned &Index,
368 unsigned &StructuredIndex,
369 bool TopLevelObject =
false);
372 llvm::APSInt elementIndex,
373 bool SubobjectIsDesignatorContext,
unsigned &Index,
375 unsigned &StructuredIndex);
381 llvm::APSInt *NextElementIndex,
384 unsigned &StructuredIndex,
385 bool FinishSubobjectInit,
386 bool TopLevelObject);
390 unsigned StructuredIndex,
392 bool IsFullyOverwritten =
false);
393 void UpdateStructuredListElement(
InitListExpr *StructuredList,
394 unsigned &StructuredIndex,
398 unsigned ExpectedNumInits);
399 int numArrayElements(
QualType DeclType);
400 int numStructUnionElements(
QualType DeclType);
408 bool UnionOverride =
false,
409 bool FullyOverwritten =
true) {
414 ? (UnionOverride ? diag::ext_initializer_union_overrides
415 : diag::ext_initializer_overrides)
416 : diag::warn_initializer_overrides;
418 if (InOverloadResolution && SemaRef.
getLangOpts().CPlusPlus) {
439 DiagID = diag::err_initializer_overrides_destructed;
459 << NewInitRange << FullyOverwritten << OldInit->
getType();
488 bool FillWithNoInit);
489 void FillInEmptyInitForField(
unsigned Init,
FieldDecl *Field,
492 bool FillWithNoInit =
false);
496 bool FillWithNoInit =
false);
499 bool TopLevelObject);
506 bool VerifyOnly,
bool TreatUnavailableAsInvalid,
507 bool InOverloadResolution =
false,
512 : InitListChecker(S, Entity, IL, T,
true,
515 &AggrDeductionCandidateParamTypes){};
517 bool HadError() {
return hadError; }
521 InitListExpr *getFullyStructuredList()
const {
return FullyStructuredList; }
538 bool EmptyInitList = SemaRef.
getLangOpts().CPlusPlus11 &&
551 InitExpr = VerifyOnly
569 if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
573 InitSeq.getFailedCandidateSet()
574 .BestViableFunction(SemaRef,
Kind.getLocation(), Best);
576 assert(O ==
OR_Success &&
"Inconsistent overload resolution");
583 bool IsInStd =
false;
585 ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
590 if (IsInStd && llvm::StringSwitch<bool>(R->
getName())
591 .Cases(
"basic_string",
"deque",
"forward_list",
true)
592 .Cases(
"list",
"map",
"multimap",
"multiset",
true)
593 .Cases(
"priority_queue",
"queue",
"set",
"stack",
true)
594 .Cases(
"unordered_map",
"unordered_set",
"vector",
true)
596 InitSeq.InitializeFrom(
600 TreatUnavailableAsInvalid);
605 diag::warn_invalid_initializer_from_system_header);
608 diag::note_used_in_initialization_here);
610 SemaRef.
Diag(Loc, diag::note_used_in_initialization_here);
617 InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
620 diag::note_in_omitted_aggregate_initializer)
623 bool IsTrailingArrayNewMember =
626 SemaRef.
Diag(Loc, diag::note_in_omitted_aggregate_initializer)
627 << (IsTrailingArrayNewMember ? 2 : 0)
636 : InitSeq.Perform(SemaRef, Entity,
Kind, SubInit);
644 if (FullyStructuredList)
646 PerformEmptyInit(Loc, Entity);
649void InitListChecker::FillInEmptyInitForBase(
652 bool &RequiresSecondPass,
bool FillWithNoInit) {
659 : PerformEmptyInit(ILE->
getEndLoc(), BaseEntity);
666 assert(Init < ILE->getNumInits() &&
"should have been expanded");
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->getSize().getZExtValue();
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->getSize().getZExtValue());
1024int InitListChecker::numStructUnionElements(
QualType DeclType) {
1026 int InitializableMembers = 0;
1027 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl))
1028 InitializableMembers += CXXRD->getNumBases();
1029 for (
const auto *Field : structDecl->
fields())
1030 if (!
Field->isUnnamedBitfield())
1031 ++InitializableMembers;
1034 return std::min(InitializableMembers, 1);
1040 return RT->getDecl();
1042 return Inject->getDecl();
1072 if (
CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(ParentRD)) {
1073 if (CXXRD->getNumBases()) {
1077 auto FieldIt = ParentRD->field_begin();
1078 assert(FieldIt != ParentRD->field_end() &&
1079 "no fields but have initializer for member?");
1080 return ++FieldIt == ParentRD->field_end();
1096 unsigned &StructuredIndex) {
1097 int maxElements = 0;
1100 maxElements = numArrayElements(T);
1102 maxElements = numStructUnionElements(T);
1106 llvm_unreachable(
"CheckImplicitInitList(): Illegal type");
1108 if (maxElements == 0) {
1111 diag::err_implicit_empty_initializer);
1118 InitListExpr *StructuredSubobjectInitList = getStructuredSubobjectInit(
1119 ParentIList, Index, T, StructuredList, StructuredIndex,
1122 unsigned StructuredSubobjectInitIndex = 0;
1125 unsigned StartIndex = Index;
1126 CheckListElementTypes(Entity, ParentIList, T,
1128 StructuredSubobjectInitList,
1129 StructuredSubobjectInitIndex);
1131 if (StructuredSubobjectInitList) {
1132 StructuredSubobjectInitList->
setType(T);
1134 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
1137 if (EndIndex < ParentIList->getNumInits() &&
1138 ParentIList->
getInit(EndIndex)) {
1149 diag::warn_missing_braces)
1155 StructuredSubobjectInitList->
getEndLoc()),
1161 if (!VerifyOnly && CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1163 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1179 unsigned DiagID = 0;
1191 DiagID = diag::warn_braces_around_init;
1198 DiagID = diag::warn_braces_around_init;
1224 llvm_unreachable(
"unexpected braced scalar init");
1243 bool TopLevelObject) {
1244 unsigned Index = 0, StructuredIndex = 0;
1245 CheckListElementTypes(Entity, IList, T,
true,
1246 Index, StructuredList, StructuredIndex, TopLevelObject);
1247 if (StructuredList) {
1253 StructuredList->
setType(ExprTy);
1261 bool ExtraInitsIsError = SemaRef.
getLangOpts().CPlusPlus ||
1263 hadError = ExtraInitsIsError;
1266 }
else if (StructuredIndex == 1 &&
1271 ? diag::err_excess_initializers_in_char_array_initializer
1272 : diag::ext_excess_initializers_in_char_array_initializer;
1276 unsigned DK = ExtraInitsIsError
1277 ? diag::err_excess_initializers_for_sizeless_type
1278 : diag::ext_excess_initializers_for_sizeless_type;
1288 unsigned DK = ExtraInitsIsError ? diag::err_excess_initializers
1289 : diag::ext_excess_initializers;
1297 !isa<InitListExpr>(IList->
getInit(0)))
1303 if (CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1306 bool HasEquivCtor =
false;
1312 if (!HasEquivCtor) {
1314 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1324 bool SubobjectIsDesignatorContext,
1327 unsigned &StructuredIndex,
1328 bool TopLevelObject) {
1332 CheckComplexType(Entity, IList, DeclType, Index,
1333 StructuredList, StructuredIndex);
1335 CheckScalarType(Entity, IList, DeclType, Index,
1336 StructuredList, StructuredIndex);
1338 CheckVectorType(Entity, IList, DeclType, Index,
1339 StructuredList, StructuredIndex);
1340 }
else if (
const RecordDecl *RD = getRecordDecl(DeclType)) {
1346 "non-aggregate records should be handed in CheckSubElementType");
1347 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1348 Bases = CXXRD->bases();
1350 Bases = cast<CXXRecordDecl>(RD)->bases();
1352 CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(),
1353 SubobjectIsDesignatorContext, Index, StructuredList,
1354 StructuredIndex, TopLevelObject);
1359 CheckArrayType(Entity, IList, DeclType, Zero,
1360 SubobjectIsDesignatorContext, Index,
1361 StructuredList, StructuredIndex);
1366 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1370 CheckReferenceType(Entity, IList, DeclType, Index,
1371 StructuredList, StructuredIndex);
1374 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_init_objc_class) << DeclType;
1379 CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1386 assert(AggrDeductionCandidateParamTypes);
1387 AggrDeductionCandidateParamTypes->push_back(DeclType);
1390 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1401 unsigned &StructuredIndex,
1402 bool DirectlyDesignated) {
1406 return CheckReferenceType(Entity, IList, ElemType, Index,
1407 StructuredList, StructuredIndex);
1410 if (SubInitList->getNumInits() == 1 &&
1415 expr = SubInitList->getInit(0);
1418 }
else if (isa<ImplicitValueInitExpr>(
expr)) {
1422 "found implicit initialization for the wrong type");
1423 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1445 if (TmpEntity.getType()->isDependentType()) {
1450 assert(AggrDeductionCandidateParamTypes);
1451 if (!isa_and_nonnull<ConstantArrayType>(
1454 AggrDeductionCandidateParamTypes->push_back(ElemType);
1466 if (
Seq || isa<InitListExpr>(
expr)) {
1469 if (Result.isInvalid())
1472 UpdateStructuredListElement(StructuredList, StructuredIndex,
1473 Result.getAs<
Expr>());
1476 }
else if (StructuredList) {
1477 UpdateStructuredListElement(StructuredList, StructuredIndex,
1481 if (AggrDeductionCandidateParamTypes)
1482 AggrDeductionCandidateParamTypes->push_back(ElemType);
1490 return CheckScalarType(Entity, IList, ElemType, Index,
1491 StructuredList, StructuredIndex);
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 ||
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);
2475 PE = IndirectField->
chain_end(); PI != PE; ++PI) {
2483 assert(isa<FieldDecl>(*PI));
2484 Replacements.back().setFieldDecl(cast<FieldDecl>(*PI));
2491 &Replacements[0] + Replacements.size());
2498 for (
unsigned I = 0; I < NumIndexExprs; ++I)
2512 explicit FieldInitializerValidatorCCC(
const RecordDecl *RD)
2520 std::unique_ptr<CorrectionCandidateCallback>
clone()
override {
2521 return std::make_unique<FieldInitializerValidatorCCC>(*
this);
2574 llvm::APSInt *NextElementIndex,
2577 unsigned &StructuredIndex,
2578 bool FinishSubobjectInit,
2579 bool TopLevelObject) {
2580 if (DesigIdx == DIE->
size()) {
2587 assert(isa<InitListExpr>(
Init) &&
2588 "designator result in direct non-list initialization?");
2593 if (StructuredList) {
2597 UpdateStructuredListElement(StructuredList, StructuredIndex,
2601 if (AggrDeductionCandidateParamTypes)
2602 AggrDeductionCandidateParamTypes->push_back(CurrentObjectType);
2607 bool prevHadError = hadError;
2612 unsigned OldIndex = Index;
2615 CheckSubElementType(Entity, IList, CurrentObjectType, Index, StructuredList,
2616 StructuredIndex,
true);
2622 IList->
setInit(OldIndex, DIE);
2624 return hadError && !prevHadError;
2628 bool IsFirstDesignator = (DesigIdx == 0);
2629 if (IsFirstDesignator ? FullyStructuredList : StructuredList) {
2632 if (IsFirstDesignator)
2633 StructuredList = FullyStructuredList;
2635 Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2636 StructuredList->getInit(StructuredIndex) :
nullptr;
2637 if (!ExistingInit && StructuredList->hasArrayFiller())
2638 ExistingInit = StructuredList->getArrayFiller();
2641 StructuredList = getStructuredSubobjectInit(
2642 IList, Index, CurrentObjectType, StructuredList, StructuredIndex,
2644 else if (
InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2645 StructuredList = Result;
2658 diagnoseInitOverride(ExistingInit,
2665 dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2666 StructuredList = E->getUpdater();
2671 StructuredList->updateInit(SemaRef.
Context, StructuredIndex, DIUE);
2680 StructuredList =
nullptr;
2696 RecordDecl *RD = getRecordDecl(CurrentObjectType);
2702 SemaRef.
Diag(Loc, diag::err_field_designator_non_aggr)
2703 << SemaRef.
getLangOpts().CPlusPlus << CurrentObjectType;
2712 if (
auto *FD = dyn_cast_if_present<FieldDecl>(VD)) {
2714 }
else if (
auto *IFD = dyn_cast_if_present<IndirectFieldDecl>(VD)) {
2720 KnownField = cast<FieldDecl>(*IFD->chain_begin());
2739 SemaRef.
Diag(Lookup.front()->getLocation(),
2740 diag::note_field_designator_found);
2747 FieldInitializerValidatorCCC CCC(RD);
2754 SemaRef.
PDiag(diag::err_field_designator_unknown_suggest)
2755 << FieldName << CurrentObjectType);
2756 KnownField = Corrected.getCorrectionDeclAs<
FieldDecl>();
2767 SemaRef.
Diag(Loc, diag::err_field_designator_unknown)
2775 unsigned NumBases = 0;
2776 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2777 NumBases = CXXRD->getNumBases();
2779 unsigned FieldIndex = NumBases;
2781 for (
auto *FI : RD->
fields()) {
2782 if (FI->isUnnamedBitfield())
2798 if (StructuredList) {
2799 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2801 assert(StructuredList->getNumInits() == 1
2802 &&
"A union should never have more than one initializer!");
2804 Expr *ExistingInit = StructuredList->getInit(0);
2807 diagnoseInitOverride(
2815 StructuredList->resizeInits(SemaRef.
Context, 0);
2816 StructuredList->setInitializedFieldInUnion(
nullptr);
2819 StructuredList->setInitializedFieldInUnion(*Field);
2826 InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
2849 if (IsFirstDesignator && !VerifyOnly && SemaRef.
getLangOpts().CPlusPlus &&
2852 (*NextField)->getFieldIndex() >
Field->getFieldIndex() + 1)) {
2856 if (FI->isUnnamedBitfield())
2867 diag::ext_designated_init_reordered)
2870 unsigned OldIndex = StructuredIndex - 1;
2871 if (StructuredList && OldIndex <= StructuredList->getNumInits()) {
2872 if (
Expr *PrevInit = StructuredList->getInit(OldIndex)) {
2873 SemaRef.
Diag(PrevInit->getBeginLoc(),
2874 diag::note_previous_field_init)
2888 if (StructuredList && FieldIndex >= StructuredList->getNumInits())
2889 StructuredList->resizeInits(SemaRef.
Context, FieldIndex + 1);
2892 if (
Field->getType()->isIncompleteArrayType()) {
2894 if ((DesigIdx + 1) != DIE->
size()) {
2901 diag::err_designator_into_flexible_array_member)
2903 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2909 if (!hadError && !isa<InitListExpr>(DIE->
getInit()) &&
2910 !isa<StringLiteral>(DIE->
getInit())) {
2914 diag::err_flexible_array_init_needs_braces)
2916 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2923 if (!
Invalid && CheckFlexibleArrayInit(Entity, DIE->
getInit(), *Field,
2933 bool prevHadError = hadError;
2934 unsigned newStructuredIndex = FieldIndex;
2935 unsigned OldIndex = Index;
2940 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2941 StructuredList, newStructuredIndex);
2943 IList->
setInit(OldIndex, DIE);
2944 if (hadError && !prevHadError) {
2949 StructuredIndex = FieldIndex;
2955 unsigned newStructuredIndex = FieldIndex;
2959 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2960 FieldType,
nullptr,
nullptr, Index,
2961 StructuredList, newStructuredIndex,
2962 FinishSubobjectInit,
false))
2973 if (IsFirstDesignator) {
2980 StructuredIndex = FieldIndex;
2984 if (!FinishSubobjectInit)
2992 bool prevHadError = hadError;
2997 CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,
2998 false, Index, StructuredList, FieldIndex);
2999 return hadError && !prevHadError;
3021 << CurrentObjectType;
3026 Expr *IndexExpr =
nullptr;
3027 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
3031 DesignatedEndIndex = DesignatedStartIndex;
3035 DesignatedStartIndex =
3037 DesignatedEndIndex =
3046 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
3051 if (isa<ConstantArrayType>(AT)) {
3052 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(),
false);
3053 DesignatedStartIndex
3054 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
3055 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
3057 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
3058 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
3059 if (DesignatedEndIndex >= MaxElements) {
3062 diag::err_array_designator_too_large)
3069 unsigned DesignatedIndexBitWidth =
3071 DesignatedStartIndex =
3072 DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
3073 DesignatedEndIndex =
3074 DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
3075 DesignatedStartIndex.setIsUnsigned(
true);
3076 DesignatedEndIndex.setIsUnsigned(
true);
3079 bool IsStringLiteralInitUpdate =
3080 StructuredList && StructuredList->isStringLiteralInit();
3081 if (IsStringLiteralInitUpdate && VerifyOnly) {
3084 StructuredList =
nullptr;
3085 }
else if (IsStringLiteralInitUpdate) {
3098 unsigned PromotedCharTyWidth = Context.
getTypeSize(PromotedCharTy);
3103 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
3104 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
3105 StructuredList->resizeInits(Context, StrLen);
3109 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
3110 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
3112 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
3113 if (CharTy != PromotedCharTy)
3117 StructuredList->updateInit(Context, i,
Init);
3126 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
3127 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
3128 StructuredList->resizeInits(Context, StrLen);
3132 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
3133 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
3135 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
3136 if (CharTy != PromotedCharTy)
3140 StructuredList->updateInit(Context, i,
Init);
3147 if (StructuredList &&
3148 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
3149 StructuredList->resizeInits(SemaRef.
Context,
3150 DesignatedEndIndex.getZExtValue() + 1);
3156 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
3157 unsigned OldIndex = Index;
3162 while (DesignatedStartIndex <= DesignatedEndIndex) {
3168 if (CheckDesignatedInitializer(
3169 ElementEntity, IList, DIE, DesigIdx + 1, ElementType,
nullptr,
3170 nullptr, Index, StructuredList, ElementIndex,
3171 FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),
3176 ++DesignatedStartIndex;
3177 ElementIndex = DesignatedStartIndex.getZExtValue();
3182 if (IsFirstDesignator) {
3183 if (NextElementIndex)
3184 *NextElementIndex = DesignatedStartIndex;
3185 StructuredIndex = ElementIndex;
3189 if (!FinishSubobjectInit)
3193 bool prevHadError = hadError;
3194 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
3196 StructuredList, ElementIndex);
3197 return hadError && !prevHadError;
3203InitListChecker::getStructuredSubobjectInit(
InitListExpr *IList,
unsigned Index,
3206 unsigned StructuredIndex,
3208 bool IsFullyOverwritten) {
3209 if (!StructuredList)
3212 Expr *ExistingInit =
nullptr;
3213 if (StructuredIndex < StructuredList->getNumInits())
3214 ExistingInit = StructuredList->
getInit(StructuredIndex);
3216 if (
InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
3225 if (!IsFullyOverwritten)
3248 diagnoseInitOverride(ExistingInit, InitRange);
3251 unsigned ExpectedNumInits = 0;
3252 if (Index < IList->getNumInits()) {
3253 if (
auto *
Init = dyn_cast_or_null<InitListExpr>(IList->
getInit(Index)))
3254 ExpectedNumInits =
Init->getNumInits();
3260 createInitListExpr(CurrentObjectType, InitRange, ExpectedNumInits);
3269InitListChecker::createInitListExpr(
QualType CurrentObjectType,
3271 unsigned ExpectedNumInits) {
3275 QualType ResultType = CurrentObjectType;
3278 Result->setType(ResultType);
3281 unsigned NumElements = 0;
3286 NumElements = CAType->getSize().getZExtValue();
3289 if (NumElements > ExpectedNumInits)
3293 NumElements = VType->getNumElements();
3295 NumElements = numStructUnionElements(CurrentObjectType);
3300 Result->reserveInits(SemaRef.
Context, NumElements);
3307void InitListChecker::UpdateStructuredListElement(
InitListExpr *StructuredList,
3308 unsigned &StructuredIndex,
3311 if (!StructuredList)
3315 StructuredIndex,
expr)) {
3321 diagnoseInitOverride(PrevInit,
expr->getSourceRange());
3332 InitListChecker Check(*
this, Entity, From,
Type,
true,
3335 return !Check.HadError();
3356 return S.
Diag(Loc, diag::err_array_designator_negative)
3359 Value.setIsUnsigned(
true);
3378 Designators.push_back(ASTDesignator::CreateFieldDesignator(
3382 llvm::APSInt IndexValue;
3383 if (!Index->isTypeDependent() && !Index->isValueDependent())
3388 Designators.push_back(ASTDesignator::CreateArrayDesignator(
3390 InitExpressions.push_back(Index);
3395 llvm::APSInt StartValue;
3396 llvm::APSInt EndValue;
3401 if (!StartDependent)
3407 if (!StartIndex || !EndIndex)
3411 if (StartDependent || EndDependent) {
3413 }
else if (StartValue.getBitWidth() > EndValue.getBitWidth())
3414 EndValue = EndValue.extend(StartValue.getBitWidth());
3415 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
3416 StartValue = StartValue.extend(EndValue.getBitWidth());
3418 if (!StartDependent && !EndDependent && EndValue < StartValue) {
3424 Designators.push_back(ASTDesignator::CreateArrayRangeDesignator(
3427 InitExpressions.push_back(StartIndex);
3428 InitExpressions.push_back(EndIndex);
3438 EqualOrColonLoc, GNUSyntax,
3446InitializedEntity::InitializedEntity(
ASTContext &Context,
unsigned Index,
3451 Kind = EK_ArrayElement;
3454 Kind = EK_VectorElement;
3458 assert(CT &&
"Unexpected type");
3459 Kind = EK_ComplexElement;
3467 bool IsInheritedVirtualBase,
3472 Result.Base = {
Base, IsInheritedVirtualBase};
3490 return Variable.VariableOrMember->getDeclName();
3512 llvm_unreachable(
"Invalid EntityKind!");
3546 llvm_unreachable(
"Invalid EntityKind!");
3581unsigned InitializedEntity::dumpImpl(raw_ostream &OS)
const {
3584 for (
unsigned I = 0; I != Depth; ++I)
3601 case EK_New: OS <<
"New";
break;
3605 case EK_Base: OS <<
"Base";
break;
3612 OS <<
"Block (lambda)";
3615 OS <<
"LambdaCapture ";
3622 D->printQualifiedName(OS);
3625 OS <<
" '" <<
getType() <<
"'\n";
3631 dumpImpl(llvm::errs());
3686 for (
const Step &S : llvm::reverse(Steps)) {
3746 llvm_unreachable(
"Invalid EntityKind!");
3754InitializationSequence
3757 bool HadMultipleCandidates) {
3761 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3763 S.Function.FoundDecl = Found;
3782 bool BindingTemporary) {
3807 bool HadMultipleCandidates) {
3811 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3813 S.Function.FoundDecl = FoundDecl;
3852 bool TopLevelOfInitList) {
3870 bool HadMultipleCandidates,
bool FromInitList,
bool AsInitList) {
3876 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3877 S.Function.Function = Constructor;
3878 S.Function.FoundDecl = FoundDecl;
3921 Steps.insert(Steps.begin(), S);
3982 "Can only rewrap trivial init lists.");
3986 Steps.insert(Steps.begin(), S);
3990 S.WrappingSyntacticList = Syntactic;
3997 this->Failure = Failure;
3998 this->FailedOverloadResult =
Result;
4019 if (!
Init.empty()) {
4039 "consuming an object of unretainable type?");
4060 bool TreatUnavailableAsInvalid);
4071 bool TreatUnavailableAsInvalid) {
4085 List->getNumInits()),
4090 List->getExprLoc(), List->getBeginLoc(), List->getEndLoc());
4092 TreatUnavailableAsInvalid);
4119 bool CopyInitializing,
bool AllowExplicit,
bool OnlyListConstructors,
4120 bool IsListInit,
bool RequireActualConstructor,
4121 bool SecondStepOfCopyInit =
false) {
4127 if (!Info.Constructor || Info.Constructor->isInvalidDecl())
4144 bool SuppressUserConversions =
4145 SecondStepOfCopyInit ||
4146 (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
4149 if (Info.ConstructorTmpl)
4151 Info.ConstructorTmpl, Info.FoundDecl,
4152 nullptr, Args, CandidateSet, SuppressUserConversions,
4153 false, AllowExplicit);
4162 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
4166 CandidateSet, SuppressUserConversions,
4167 false, AllowExplicit,
4183 if (S.
getLangOpts().CPlusPlus17 && Args.size() == 1 &&
4184 !RequireActualConstructor && !SecondStepOfCopyInit) {
4186 auto *SourceRD =
Initializer->getType()->getAsCXXRecordDecl();
4188 const auto &Conversions = SourceRD->getVisibleConversionFunctions();
4189 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4199 Conv = cast<CXXConversionDecl>(D);
4203 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4204 CandidateSet, AllowExplicit, AllowExplicit,
4208 DestType, CandidateSet, AllowExplicit,
4235 bool IsListInit =
false,
4236 bool IsInitListCopy =
false) {
4237 assert(((!IsListInit && !IsInitListCopy) ||
4238 (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
4239 "IsListInit/IsInitListCopy must come with a single initializer list "
4242 (IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) :
nullptr;
4252 bool RequireActualConstructor =
4267 if (S.
getLangOpts().CPlusPlus17 && !RequireActualConstructor &&
4268 UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isPRValue() &&
4278 assert(DestRecordType &&
"Constructor initialization requires record type");
4280 = cast<CXXRecordDecl>(DestRecordType->
getDecl());
4288 bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
4298 bool AsInitializerList =
false;
4310 AsInitializerList =
true;
4316 S, Kind.getLocation(), Args, CandidateSet, DestType, Ctors, Best,
4317 CopyInitialization, AllowExplicit,
4318 true, IsListInit, RequireActualConstructor);
4327 AsInitializerList =
false;
4329 S, Kind.getLocation(), UnwrappedArgs, CandidateSet, DestType, Ctors,
4330 Best, CopyInitialization, AllowExplicit,
4331 false, IsListInit, RequireActualConstructor);
4343 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4347 if (
auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
4349 QualType ConvType = CD->getConversionType();
4351 "should not have selected this conversion function");
4353 HadMultipleCandidates);
4384 if (IsListInit && !Kind.AllowExplicit() && CtorDecl->
isExplicit()) {
4404 Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,
4405 IsListInit | IsInitListCopy, AsInitializerList);
4418 bool HadMultipleCandidates =
false;
4421 UnqualifiedTargetType,
4423 &HadMultipleCandidates)) {
4425 HadMultipleCandidates);
4426 SourceType = Fn->getType();
4445 bool TopLevelOfInitList);
4459 bool TreatUnavailableAsInvalid) {
4499 T1Quals, cv2T2, T2, T2Quals, Sequence,
4530 TreatUnavailableAsInvalid);
4562 bool TreatUnavailableAsInvalid) {
4574 TreatUnavailableAsInvalid);
4612 !IsDesignatedInit) {
4617 Expr *InitListAsExpr = InitList;
4627 if (!isa<VariableArrayType>(DestAT) &&
4637 TreatUnavailableAsInvalid);
4670 TreatUnavailableAsInvalid))
4674 Expr *InitListAsExpr = InitList;
4676 DestType, Sequence,
true);
4694 ET && ET->getDecl()->isFixed() &&
4743 if (
Init->getType()->isRecordType() ||
4754 TreatUnavailableAsInvalid);
4761 InitListChecker CheckInitList(S, Entity, InitList,
4762 DestType,
true, TreatUnavailableAsInvalid);
4763 if (CheckInitList.HadError()) {
4785 "Must have incompatible references when binding via conversion");
4796 bool AllowExplicitCtors =
false;
4797 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
4808 if (!Info.Constructor)
4811 if (!Info.Constructor->isInvalidDecl() &&
4812 Info.Constructor->isConvertingConstructor(
true)) {
4813 if (Info.ConstructorTmpl)
4815 Info.ConstructorTmpl, Info.FoundDecl,
4818 false, AllowExplicitCtors);
4821 Info.Constructor, Info.FoundDecl,
Initializer, CandidateSet,
4823 false, AllowExplicitCtors);
4838 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4841 if (isa<UsingShadowDecl>(D))
4842 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4849 Conv = cast<CXXConversionDecl>(D);
4857 if ((AllowRValues ||
4861 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4863 false, AllowExplicitConvs);
4866 Conv, I.getPair(), ActingDC,
Initializer, DestType, CandidateSet,
4867 false, AllowExplicitConvs);
4889 if (isa<CXXConversionDecl>(
Function))
4902 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4904 HadMultipleCandidates);
4914 assert(!isa<CXXConstructorDecl>(
Function) &&
4915 "should not have conversion after constructor");
4919 ICS.
Standard = Best->FinalConversion;
4940 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
4942 else if (RefConv & Sema::ReferenceConversions::ObjC)
4944 else if (RefConv & Sema::ReferenceConversions::Function)
4946 else if (RefConv & Sema::ReferenceConversions::Qualification) {
4963 bool TopLevelOfInitList) {
4981 T1Quals, cv2T2, T2, T2Quals, Sequence,
4982 TopLevelOfInitList);
5006 bool TopLevelOfInitList) {
5030 if (isLValueRef || T1Function) {
5033 (Kind.isCStyleOrFunctionalCast() &&
5037 if (RefConv & (Sema::ReferenceConversions::DerivedToBase |
5038 Sema::ReferenceConversions::ObjC)) {
5041 if (RefConv & (Sema::ReferenceConversions::Qualification))
5045 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
5049 }
else if (RefConv & Sema::ReferenceConversions::Qualification) {
5053 }
else if (RefConv & Sema::ReferenceConversions::Function) {
5073 (isLValueRef || InitCategory.
isRValue())) {
5078 isLValueRef, Sequence);
5112 switch (RefRelationship) {
5124 llvm_unreachable(
"unexpected kind of compatible initializer");
5148 (Kind.isCStyleOrFunctionalCast() &&
5177 auto T1QualsIgnoreAS = T1Quals;
5178 auto T2QualsIgnoreAS = T2Quals;
5181 T2QualsIgnoreAS.removeAddressSpace();
5184 if (T1QualsIgnoreAS != T2QualsIgnoreAS)
5194 cv1T4 = cv1T4WithAS;
5199 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
5201 else if (RefConv & Sema::ReferenceConversions::ObjC)
5203 else if (RefConv & Sema::ReferenceConversions::Qualification) {
5220 isLValueRef, Sequence);
5260 Sema::AllowedExplicit::None,
5262 Kind.isCStyleOrFunctionalCast(),
5281 TopLevelOfInitList);
5290 ((T1CVRQuals | T2CVRQuals) != T1CVRQuals ||
5335 assert((!InitList || InitList->
getNumInits() == 0) &&
5336 "Shouldn't use value-init for non-empty init lists");
5347 if (
CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
5348 bool NeedZeroInitialization =
true;
5363 NeedZeroInitialization =
false;
5371 if (NeedZeroInitialization)
5385 ClassDecl->hasUninitializedReferenceMember()) {
5393 Expr *InitListAsExpr = InitList;
5395 bool InitListSyntax = InitList;
5400 S, Entity, Kind, Args, T, Entity.
getType(), Sequence, InitListSyntax);
5450 unsigned EntityIndexToProcess = 0;
5453 Expr *ArrayFiller =
nullptr;
5454 FieldDecl *InitializedFieldInUnion =
nullptr;
5458 Expr *Arg,
Expr **InitExpr =
nullptr) {
5460 S, SubEntity, SubKind, Arg ?
MultiExprArg(Arg) : std::nullopt);
5474 ER = IS.
Perform(S, SubEntity, SubKind,
5477 *InitExpr = ER.
get();
5479 InitExprs.push_back(ER.
get());
5487 uint64_t ArrayLength;
5495 ArrayLength = CAT->getSize().getZExtValue();
5496 ResultType = Entity.
getType();
5503 const Expr *SE = VAT->getSizeExpr();
5508 assert(isa<IncompleteArrayType>(Entity.
getType()));
5509 ArrayLength = Args.size();
5511 EntityIndexToProcess = ArrayLength;
5515 for (
Expr *E : Args) {
5520 if (!HandleInitializedEntity(SubEntity, SubKind, E))
5528 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
true);
5529 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr, &ArrayFiller))
5533 if (ResultType.
isNull()) {
5540 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
5554 if (EntityIndexToProcess < Args.size()) {
5560 Expr *E = Args[EntityIndexToProcess];
5563 if (!HandleInitializedEntity(SubEntity, SubKind, E))
5571 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
5573 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr))
5576 EntityIndexToProcess++;
5589 if (EntityIndexToProcess < Args.size()) {
5591 Expr *E = Args[EntityIndexToProcess];
5609 if (!HandleInitializedEntity(SubEntity, SubKind, E))
5617 InitializedFieldInUnion = FD;
5618 EntityIndexToProcess = 1;
5630 Kind.getParenOrBraceRange().getEnd(), FD);
5634 InitExprs.push_back(DIE.
get());
5644 S.
Diag(SR.
getEnd(), diag::err_init_reference_member_uninitialized)
5651 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
true);
5652 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr))
5656 EntityIndexToProcess++;
5658 ResultType = Entity.
getType();
5663 if (EntityIndexToProcess < Args.size()) {
5668 SourceRange ExcessInitSR(Args[EntityIndexToProcess]->getBeginLoc(),
5669 Args.back()->getEndLoc());
5670 S.
Diag(Kind.getLocation(), diag::err_excess_initializers)
5671 << InitKind << ExcessInitSR;
5685 CPLIE->setArrayFiller(ArrayFiller);
5686 if (InitializedFieldInUnion)
5687 CPLIE->setInitializedFieldInUnion(InitializedFieldInUnion);
5689 S.
Diag(Kind.getLocation(),
5690 diag::warn_cxx17_compat_aggregate_init_paren_list)
5691 << Kind.getLocation() << SR << ResultType;
5703 bool TopLevelOfInitList) {
5704 assert(!DestType->
isReferenceType() &&
"References are handled elsewhere");
5707 "Must have a class type to perform a user-defined conversion");
5717 bool AllowExplicit = Kind.AllowExplicit();
5723 = cast<CXXRecordDecl>(DestRecordType->getDecl());
5729 if (!Info.Constructor)
5732 if (!Info.Constructor->isInvalidDecl() &&
5733 Info.Constructor->isConvertingConstructor(
true)) {
5734 if (Info.ConstructorTmpl)
5736 Info.ConstructorTmpl, Info.FoundDecl,
5739 false, AllowExplicit);
5744 false, AllowExplicit);
5760 = cast<CXXRecordDecl>(SourceRecordType->getDecl());
5762 const auto &Conversions =
5764 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
5767 if (isa<UsingShadowDecl>(D))
5768 D = cast<UsingShadowDecl>(D)->getTargetDecl();
5775 Conv = cast<CXXConversionDecl>(D);
5779 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
5780 CandidateSet, AllowExplicit, AllowExplicit);
5783 DestType, CandidateSet, AllowExplicit,
5809 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
5811 if (isa<CXXConstructorDecl>(
Function)) {
5817 HadMultipleCandidates);
5846 HadMultipleCandidates);
5859 Function->getReturnType()->isReferenceType() ||
5869 if (Best->FinalConversion.First || Best->FinalConversion.Second ||
5870 Best->FinalConversion.Third) {
5873 ICS.
Standard = Best->FinalConversion;
5891 isa<CXXBoolLiteralExpr>(
Init) &&
5892 !cast<CXXBoolLiteralExpr>(
Init)->getValue() &&
5901 bool isAddressOf,
bool &isWeakAccess) {
5907 if (op->getOpcode() == UO_AddrOf)
5912 }
else if (
CastExpr *ce = dyn_cast<CastExpr>(e)) {
5913 switch (ce->getCastKind()) {
5916 case CK_LValueBitCast:
5920 case CK_ArrayToPointerDecay:
5923 case CK_NullToPointer:
5931 }
else if (isa<DeclRefExpr>(e)) {
5935 isWeakAccess =
true;
5939 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
5953 }
else if (isa<ArraySubscriptExpr>(e)) {
5969 bool isWeakAccess =
false;
5973 if (S.
getLangOpts().ObjCAutoRefCount && isWeakAccess)
6005 bool ArrayDecay =
false;
6010 ArgPointee = ArgArrayType->getElementType();
6022 bool ShouldCopy =
true;
6093 "cl_intel_device_side_avc_motion_estimation", S.
getLangOpts()) &&
6095 if (DestType->isOCLIntelSubgroupAVCMcePayloadType() ||
6096 DestType->isOCLIntelSubgroupAVCMceResultType())
6110 MultiExprArg Args,
bool TopLevelOfInitList,
bool TreatUnavailableAsInvalid)
6114 TreatUnavailableAsInvalid);
6120 auto *DRE = dyn_cast<DeclRefExpr>(E);
6121 if (!DRE || !isa<FunctionDecl>(DRE->getDecl()))
6125 cast<FunctionDecl>(DRE->getDecl()));
6142 return isa<DecompositionDecl>(Entity.
getDecl());
6168 bool TopLevelOfInitList,
6169 bool TreatUnavailableAsInvalid) {
6176 for (
unsigned I = 0, E = Args.size(); I != E; ++I)
6177 if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
6184 Args[I] = result.
get();
6206 if (Args.size() == 1) {
6224 TreatUnavailableAsInvalid);
6236 if (Args.size() != 1)
6242 else if (isa<InitListExpr>(Args[0]))
6246 TopLevelOfInitList);
6269 if (
Initializer && isa<VariableArrayType>(DestAT)) {
6301 if (
Initializer && isa<ConstantArrayType>(DestAT) &&
6319 Expr *OVEAsExpr = &OVE;
6321 TreatUnavailableAsInvalid);
6331 isa<CompoundLiteralExpr>(
Initializer->IgnoreParens()) &&
6349 *
this, TreatUnavailableAsInvalid);
6351 }
else if (S.
getLangOpts().CPlusPlus20 && !TopLevelOfInitList &&
6355 else if (DestAT->getElementType()->isCharType())
6367 bool allowObjCWritebackConversion = S.
getLangOpts().ObjCAutoRefCount &&
6376 assert(
Initializer &&
"Initializer must be non-null");
6378 if (allowObjCWritebackConversion &&
6404 SourceType, DestType))))) {
6411 if (
const auto *RD =
6416 S.
getLangOpts().CPlusPlus20 && RD && RD->hasDefinition() &&
6417 RD->isAggregate() &&
Failed() &&
6430 S, Kind.getLocation(), Best);
6448 assert(
Initializer &&
"Initializer must be non-null");
6450 TopLevelOfInitList);
6455 assert(Args.size() >= 1 &&
"Zero-argument case handled above");
6465 for (
auto *Arg : Args) {
6466 if (Arg->getType()->isExtVectorType()) {
6469 for (
unsigned Idx = 0; Idx < Elm; ++Idx) {
6475 VTy->getElementType(), Arg->
getValueKind(), Arg->getObjectKind(),
6479 InitArgs.emplace_back(Arg);
6489 if (Args.size() > 1) {
6492 }
else if (isa<InitListExpr>(Args[0])) {
6500 assert(
Initializer &&
"Initializer must be non-null");
6503 bool NeedAtomicConversion =
false;
6507 Atomic->getValueType())) {
6508 DestType =
Atomic->getValueType();
6509 NeedAtomicConversion =
true;
6514 TopLevelOfInitList);
6516 if (!
Failed() && NeedAtomicConversion)
6543 Sema::AllowedExplicit::None,
6545 Kind.isCStyleOrFunctionalCast(),
6546 allowObjCWritebackConversion);
6554 bool ShouldCopy =
true;
6570 }
else if (ICS.
isBad()) {
6578 else if (
Initializer->getType()->isFunctionType() &&
6591 for (
auto &S : Steps)
6649 llvm_unreachable(
"Invalid EntityKind!");
6683 llvm_unreachable(
"missed an InitializedEntity kind?");
6717 llvm_unreachable(
"missed an InitializedEntity kind?");
6756 llvm_unreachable(
"missed an InitializedEntity kind?");
6783 bool IsExtraneousCopy) {
6808 S, Loc, CurInitExpr, CandidateSet, T, Ctors, Best,
6820 ? diag::ext_rvalue_to_reference_temp_copy_no_viable
6821 : diag::err_temp_copy_no_viable)
6839 S.
Diag(Loc, diag::err_temp_copy_deleted)
6846 bool HadMultipleCandidates = CandidateSet.
size() > 1;
6855 if (IsExtraneousCopy) {
6866 for (
unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
6869 diag::err_call_incomplete_argument))
6910 Best->Function->getParamDecl(0)->getType().getNonReferenceType(),
6915 Loc, T, Best->FoundDecl, Constructor, Elidable, ConstructorArgs,
6916 HadMultipleCandidates,
6932 Expr *CurInitExpr) {
6951 S, Loc, CurInitExpr, CandidateSet, CurInitExpr->
getType(), Ctors, Best,
6964 Best->FoundDecl, Entity,
Diag);
6985void InitializationSequence::PrintInitLocationNote(
Sema &S,
7000 diag::note_method_return_type_change)
7018 switch (Kind.getKind()) {
7024 return NumArgs != 1;
7036 bool &ConstructorInitRequiresZeroInit,
7037 bool IsListInitialization,
7038 bool IsStdInitListInitialization,
7041 unsigned NumArgs = Args.size();
7048 SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
7049 ? Kind.getEqualLoc()
7050 : Kind.getLocation();
7056 assert(Constructor->getParent() &&
"No parent class for constructor.");
7057 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
7058 Constructor->isTrivial() && !Constructor->isUsed(
false)) {
7073 bool AllowExplicitConv =
7074 Kind.AllowExplicit() && !Kind.isCopyInit() && Args.size() == 1 &&
7081 ConstructorArgs, AllowExplicitConv,
7082 IsListInitialization))
7096 : Kind.getParenOrBraceRange();
7099 if (
auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(
7109 ConstructorArgs, ParenOrBraceRange, HadMultipleCandidates,
7110 IsListInitialization, IsStdInitListInitialization,
7111 ConstructorInitRequiresZeroInit),
7127 if (IsListInitialization)
7128 ParenOrBraceRange =
SourceRange(LBraceLoc, RBraceLoc);
7130 ParenOrBraceRange = Kind.getParenOrBraceRange();
7139 HadMultipleCandidates,
7140 IsListInitialization,
7141 IsStdInitListInitialization,
7142 ConstructorInitRequiresZeroInit,
7150 HadMultipleCandidates,
7151 IsListInitialization,
7152 IsStdInitListInitialization,
7153 ConstructorInitRequiresZeroInit,
7201using LifetimeResult =
7202 llvm::PointerIntPair<const InitializedEntity *, 3, LifetimeKind>;
7215 return {Entity, LK_Extended};
7235 : LK_MemInitializer};
7240 return {Entity, LK_Extended};
7247 return {
nullptr, LK_FullExpression};
7251 return {
nullptr, LK_FullExpression};
7257 return {
nullptr, LK_Return};
7262 return {
nullptr, LK_StmtExprResult};
7268 return {
nullptr, LK_New};
7276 return {
nullptr, LK_FullExpression};
7286 return {InitField, LK_MemInitializer};
7293 return {InitField, LK_MemInitializer};
7300 return {
nullptr, LK_FullExpression};
7304 return {
nullptr, LK_FullExpression};
7311 return {
nullptr, LK_FullExpression};
7314 llvm_unreachable(
"unknown entity kind");
7320 RK_ReferenceBinding,
7323 RK_StdInitializerList,
7336struct IndirectLocalPathEntry {
7350 const Decl *D =
nullptr;
7353 IndirectLocalPathEntry() {}
7354 IndirectLocalPathEntry(EntryKind K,
Expr *E) :
Kind(K), E(E) {}
7355 IndirectLocalPathEntry(EntryKind K,
Expr *E,
const Decl *D)
7356 :
Kind(K), E(E), D(D) {}
7363struct RevertToOldSizeRAII {
7364 IndirectLocalPath &Path;
7365 unsigned OldSize = Path.size();
7366 RevertToOldSizeRAII(IndirectLocalPath &Path) : Path(Path) {}
7367 ~RevertToOldSizeRAII() { Path.resize(OldSize); }
7370using LocalVisitor = llvm::function_ref<
bool(IndirectLocalPath &Path, Local L,
7376 if (E.Kind == IndirectLocalPathEntry::VarInit && E.D == VD)
7382 return llvm::any_of(Path, [=](IndirectLocalPathEntry E) {
7383 return E.Kind == IndirectLocalPathEntry::DefaultInit ||
7384 E.Kind == IndirectLocalPathEntry::VarInit;
7390 bool RevisitSubinits,
7391 bool EnableLifetimeWarnings);
7396 bool EnableLifetimeWarnings);
7411 if (
const auto *ND = dyn_cast<NamespaceDecl>(DC))
7413 StringRef Name = II->getName();
7414 if (Name.size() >= 2 && Name.front() ==
'_' &&
7423 if (
auto *Conv = dyn_cast_or_null<CXXConversionDecl>(Callee))
7424 if (isRecordWithAttr<PointerAttr>(Conv->getConversionType()))
7428 if (!isRecordWithAttr<PointerAttr>(
7429 Callee->getFunctionObjectParameterType()) &&
7430 !isRecordWithAttr<OwnerAttr>(Callee->getFunctionObjectParameterType()))
7432 if (Callee->getReturnType()->isPointerType() ||
7433 isRecordWithAttr<PointerAttr>(Callee->getReturnType())) {
7434 if (!Callee->getIdentifier())
7436 return llvm::StringSwitch<bool>(Callee->getName())
7437 .Cases(
"begin",
"rbegin",
"cbegin",
"crbegin",
true)
7438 .Cases(
"end",
"rend",
"cend",
"crend",
true)
7439 .Cases(
"c_str",
"data",
"get",
true)
7441 .Cases(
"find",
"equal_range",
"lower_bound",
"upper_bound",
true)
7443 }
else if (Callee->getReturnType()->isReferenceType()) {
7444 if (!Callee->getIdentifier()) {
7445 auto OO = Callee->getOverloadedOperator();
7446 return OO == OverloadedOperatorKind::OO_Subscript ||
7447 OO == OverloadedOperatorKind::OO_Star;
7449 return llvm::StringSwitch<bool>(Callee->getName())
7450 .Cases(
"front",
"back",
"at",
"top",
"value",
true)
7467 return llvm::StringSwitch<bool>(FD->
getName())
7468 .Cases(
"begin",
"rbegin",
"cbegin",
"crbegin",
true)
7469 .Cases(
"end",
"rend",
"cend",
"crend",
true)
7473 return llvm::StringSwitch<bool>(FD->
getName())
7474 .Cases(
"get",
"any_cast",
true)
7481 LocalVisitor Visit) {
7482 auto VisitPointerArg = [&](
const Decl *D,
Expr *Arg,
bool Value) {
7485 if (isa<MemberExpr>(Arg->IgnoreImpCasts()))
7489 for (
const IndirectLocalPathEntry &PE : llvm::reverse(Path)) {
7490 if (PE.Kind == IndirectLocalPathEntry::GslReferenceInit)
7492 if (PE.Kind == IndirectLocalPathEntry::GslPointerInit)
7497 Path.push_back({
Value ? IndirectLocalPathEntry::GslPointerInit
7498 : IndirectLocalPathEntry::GslReferenceInit,
7500 if (Arg->isGLValue())
7510 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(
Call)) {
7511 const auto *MD = cast_or_null<CXXMethodDecl>(MCE->getDirectCallee());
7513 VisitPointerArg(MD, MCE->getImplicitObjectArgument(),
7514 !MD->getReturnType()->isReferenceType());
7516 }
else if (
auto *OCE = dyn_cast<CXXOperatorCallExpr>(
Call)) {
7518 if (Callee && Callee->isCXXInstanceMember() &&
7520 VisitPointerArg(Callee, OCE->getArg(0),
7521 !Callee->getReturnType()->isReferenceType());
7523 }
else if (
auto *CE = dyn_cast<CallExpr>(
Call)) {
7526 VisitPointerArg(Callee, CE->getArg(0),
7527 !Callee->getReturnType()->isReferenceType());
7531 if (
auto *CCE = dyn_cast<CXXConstructExpr>(
Call)) {
7532 const auto *Ctor = CCE->getConstructor();
7534 if (CCE->getNumArgs() > 0 && RD->
hasAttr<PointerAttr>())
7535 VisitPointerArg(Ctor->getParamDecl(0), CCE->getArgs()[0],
true);
7563 auto *MD = dyn_cast<CXXMethodDecl>(FD);
7564 if (MD && MD->isCXXInstanceMember())
7567 LHST = MD->getParamDecl(0)->getType();
7577 LocalVisitor Visit) {
7581 if (
auto *CE = dyn_cast<CallExpr>(
Call)) {
7582 Callee = CE->getDirectCallee();
7585 auto *CCE = cast<CXXConstructExpr>(
Call);
7586 Callee = CCE->getConstructor();
7592 Expr *ObjectArg =
nullptr;
7593 if (isa<CXXOperatorCallExpr>(
Call) && Callee->isCXXInstanceMember()) {
7594 ObjectArg = Args[0];
7595 Args = Args.slice(1);
7596 }
else if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(
Call)) {
7597 ObjectArg = MCE->getImplicitObjectArgument();
7600 auto VisitLifetimeBoundArg = [&](
const Decl *D,
Expr *Arg) {
7601 Path.push_back({IndirectLocalPathEntry::LifetimeBoundCall, Arg, D});
7602 if (Arg->isGLValue())
7612 bool CheckCoroCall =
false;
7613 if (
const auto *RD = Callee->getReturnType()->getAsRecordDecl()) {
7614 CheckCoroCall = RD->
hasAttr<CoroLifetimeBoundAttr>() &&
7615 RD->
hasAttr<CoroReturnTypeAttr>() &&
7616 !Callee->hasAttr<CoroDisableLifetimeBoundAttr>();
7620 bool CheckCoroObjArg = CheckCoroCall;
7622 if (
auto *LE = dyn_cast<LambdaExpr>(ObjectArg->
IgnoreImplicit());
7623 LE && LE->captures().empty())
7624 CheckCoroObjArg =
false;
7628 CheckCoroObjArg =
false;
7630 VisitLifetimeBoundArg(Callee, ObjectArg);
7633 for (
unsigned I = 0,
7634 N = std::min<unsigned>(Callee->getNumParams(), Args.size());
7636 if (CheckCoroCall || Callee->getParamDecl(I)->hasAttr<LifetimeBoundAttr>())
7637 VisitLifetimeBoundArg(Callee->getParamDecl(I), Args[I]);
7646 bool EnableLifetimeWarnings) {
7647 RevertToOldSizeRAII RAII(Path);
7654 if (
auto *FE = dyn_cast<FullExpr>(
Init))
7655 Init = FE->getSubExpr();
7665 Init =
const_cast<Expr *
>(
Init->skipRValueSubobjectAdjustments());
7670 if (CE->getSubExpr()->isGLValue())
7671 Init = CE->getSubExpr();
7675 if (
auto *ASE = dyn_cast<ArraySubscriptExpr>(
Init)) {
7676 Init = ASE->getBase();
7677 auto *ICE = dyn_cast<ImplicitCastExpr>(
Init);
7678 if (ICE && ICE->getCastKind() == CK_ArrayToPointerDecay)
7679 Init = ICE->getSubExpr();
7684 EnableLifetimeWarnings);
7689 if (
auto *DIE = dyn_cast<CXXDefaultInitExpr>(
Init)) {
7691 {IndirectLocalPathEntry::DefaultInit, DIE, DIE->getField()});
7692 Init = DIE->getExpr();
7694 }
while (
Init != Old);
7696 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(
Init)) {
7697 if (Visit(Path, Local(MTE), RK))
7699 EnableLifetimeWarnings);
7702 if (isa<CallExpr>(
Init)) {
7703 if (EnableLifetimeWarnings)
7708 switch (
Init->getStmtClass()) {
7709 case Stmt::DeclRefExprClass: {
7712 auto *DRE = cast<DeclRefExpr>(
Init);
7713 auto *VD = dyn_cast<VarDecl>(DRE->getDecl());
7714 if (VD && VD->hasLocalStorage() &&
7715 !DRE->refersToEnclosingVariableOrCapture()) {
7717 Visit(Path, Local(DRE), RK);
7718 }
else if (isa<ParmVarDecl>(DRE->getDecl())) {
7722 }
else if (VD->getInit() && !
isVarOnPath(Path, VD)) {
7723 Path.push_back({IndirectLocalPathEntry::VarInit, DRE, VD});
7725 RK_ReferenceBinding, Visit,
7726 EnableLifetimeWarnings);
7732 case Stmt::UnaryOperatorClass: {
7737 if (
U->getOpcode() == UO_Deref)
7739 EnableLifetimeWarnings);
7743 case Stmt::OMPArraySectionExprClass: {
7745 cast<OMPArraySectionExpr>(
Init)->getBase(),
7746 Visit,
true, EnableLifetimeWarnings);
7750 case Stmt::ConditionalOperatorClass:
7751 case Stmt::BinaryConditionalOperatorClass: {
7752 auto *
C = cast<AbstractConditionalOperator>(
Init);
7753 if (!
C->getTrueExpr()->getType()->isVoidType())
7755 EnableLifetimeWarnings);
7756 if (!
C->getFalseExpr()->getType()->isVoidType())
7758 EnableLifetimeWarnings);
7762 case Stmt::CompoundLiteralExprClass: {
7763 if (
auto *CLE = dyn_cast<CompoundLiteralExpr>(
Init)) {
7764 if (!CLE->isFileScope())
7765 Visit(Path, Local(CLE), RK);
7781 bool RevisitSubinits,
7782 bool EnableLifetimeWarnings) {
7783 RevertToOldSizeRAII RAII(Path);
7791 if (
auto *DIE = dyn_cast<CXXDefaultInitExpr>(
Init)) {
7792 Path.push_back({IndirectLocalPathEntry::DefaultInit, DIE, DIE->getField()});
7793 Init = DIE->getExpr();
7796 if (
auto *FE = dyn_cast<FullExpr>(
Init))
7797 Init = FE->getSubExpr();
7800 Init =
const_cast<Expr *
>(
Init->skipRValueSubobjectAdjustments());
7803 Init = BTE->getSubExpr();
7808 if (
auto *CE = dyn_cast<CastExpr>(
Init)) {
7809 switch (CE->getCastKind()) {
7810 case CK_LValueToRValue:
7813 Path.push_back({IndirectLocalPathEntry::LValToRVal, CE});
7815 Path,
Init, RK_ReferenceBinding,
7816 [&](IndirectLocalPath &Path, Local L, ReferenceKind RK) ->
bool {
7817 if (
auto *DRE = dyn_cast<DeclRefExpr>(L)) {
7818 auto *VD = dyn_cast<VarDecl>(DRE->getDecl());
7821 Path.push_back({IndirectLocalPathEntry::VarInit, DRE, VD});
7823 EnableLifetimeWarnings);
7825 }
else if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(L)) {
7826 if (MTE->getType().isConstQualified())
7828 true, EnableLifetimeWarnings);
7831 }, EnableLifetimeWarnings);
7839 case CK_BaseToDerived:
7840 case CK_DerivedToBase:
7841 case CK_UncheckedDerivedToBase:
7844 case CK_UserDefinedConversion:
7845 case CK_ConstructorConversion:
7846 case CK_IntegralToPointer:
7847 case CK_PointerToIntegral:
7848 case CK_VectorSplat:
7849 case CK_IntegralCast:
7850 case CK_CPointerToObjCPointerCast:
7851 case CK_BlockPointerToObjCPointerCast:
7852 case CK_AnyPointerToBlockPointerCast:
7853 case CK_AddressSpaceConversion:
7856 case CK_ArrayToPointerDecay:
7859 Path.push_back({IndirectLocalPathEntry::AddressOf, CE});
7861 RK_ReferenceBinding, Visit,
7862 EnableLifetimeWarnings);
7868 Init = CE->getSubExpr();
7870 }
while (Old !=
Init);
7875 if (
auto *ILE = dyn_cast<CXXStdInitializerListExpr>(
Init))
7877 RK_StdInitializerList, Visit,
7878 EnableLifetimeWarnings);
7884 if (!RevisitSubinits)
7890 EnableLifetimeWarnings);
7893 for (
unsigned I = 0, N = ILE->
getNumInits(); I != N; ++I)
7896 EnableLifetimeWarnings);
7901 assert(RD->isAggregate() &&
"aggregate init on non-aggregate");
7909 RK_ReferenceBinding, Visit,
7910 EnableLifetimeWarnings);
7913 for (; Index < RD->getNumBases() && Index < ILE->getNumInits(); ++Index)
7916 EnableLifetimeWarnings);
7917 for (
const auto *I : RD->
fields()) {
7920 if (I->isUnnamedBitfield())
7923 if (I->getType()->isReferenceType())
7925 RK_ReferenceBinding, Visit,
7926 EnableLifetimeWarnings);
7933 EnableLifetimeWarnings);
7943 if (
auto *LE = dyn_cast<LambdaExpr>(
Init)) {
7945 for (
Expr *E : LE->capture_inits()) {
7946 assert(CapI != LE->capture_end());
7951 Path.push_back({IndirectLocalPathEntry::LambdaCaptureInit, E, &Cap});
7954 Visit, EnableLifetimeWarnings);
7957 EnableLifetimeWarnings);
7965 if (
auto *CCE = dyn_cast<CXXConstructExpr>(
Init)) {
7966 if (CCE->getConstructor()->isCopyOrMoveConstructor()) {
7967 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(CCE->getArg(0))) {
7968 Expr *Arg = MTE->getSubExpr();
7969 Path.push_back({IndirectLocalPathEntry::TemporaryCopy, Arg,
7970 CCE->getConstructor()});
7978 if (isa<CallExpr>(
Init) || isa<CXXConstructExpr>(
Init)) {
7979 if (EnableLifetimeWarnings)
7984 switch (
Init->getStmtClass()) {
7985 case Stmt::UnaryOperatorClass: {
7986 auto *UO = cast<UnaryOperator>(
Init);
7989 if (UO->getOpcode() == UO_AddrOf) {
7993 if (isa<MaterializeTemporaryExpr>(UO->getSubExpr()))
7996 Path.push_back({IndirectLocalPathEntry::AddressOf, UO});
7998 RK_ReferenceBinding, Visit,
7999 EnableLifetimeWarnings);
8004 case Stmt::BinaryOperatorClass: {
8006 auto *BO = cast<BinaryOperator>(
Init);
8008 if (!BO->getType()->isPointerType() || (BOK != BO_Add && BOK != BO_Sub))
8011 if (BO->getLHS()->getType()->isPointerType())
8013 EnableLifetimeWarnings);
8014 else if (BO->getRHS()->getType()->isPointerType())
8016 EnableLifetimeWarnings);
8020 case Stmt::ConditionalOperatorClass:
8021 case Stmt::BinaryConditionalOperatorClass: {
8022 auto *
C = cast<AbstractConditionalOperator>(
Init);
8025 if (!
C->getTrueExpr()->getType()->isVoidType())
8027 EnableLifetimeWarnings);
8028 if (!
C->getFalseExpr()->getType()->isVoidType())
8030 EnableLifetimeWarnings);
8034 case Stmt::BlockExprClass:
8035 if (cast<BlockExpr>(
Init)->getBlockDecl()->hasCaptures()) {
8037 Visit(Path, Local(cast<BlockExpr>(
Init)), RK_ReferenceBinding);
8041 case Stmt::AddrLabelExprClass:
8043 Visit(Path, Local(cast<AddrLabelExpr>(
Init)), RK_ReferenceBinding);
8069 for (
auto Elem : Path) {
8070 if (Elem.Kind == IndirectLocalPathEntry::DefaultInit)
8071 Kind = PathLifetimeKind::ShouldExtend;
8072 else if (Elem.Kind != IndirectLocalPathEntry::LambdaCaptureInit)
8073 return PathLifetimeKind::NoExtend;
8081 for (
unsigned N = Path.size(); I != N; ++I) {
8082 switch (Path[I].Kind) {
8083 case IndirectLocalPathEntry::AddressOf:
8084 case IndirectLocalPathEntry::LValToRVal:
8085 case IndirectLocalPathEntry::LifetimeBoundCall:
8086 case IndirectLocalPathEntry::TemporaryCopy:
8087 case IndirectLocalPathEntry::GslReferenceInit:
8088 case IndirectLocalPathEntry::GslPointerInit:
8093 case IndirectLocalPathEntry::VarInit:
8094 if (cast<VarDecl>(Path[I].D)->isImplicit())
8097 case IndirectLocalPathEntry::DefaultInit:
8098 return Path[I].E->getSourceRange();
8100 case IndirectLocalPathEntry::LambdaCaptureInit:
8101 if (!Path[I].
Capture->capturesVariable())
8103 return Path[I].E->getSourceRange();
8110 for (
const auto &It : llvm::reverse(Path)) {
8111 if (It.Kind == IndirectLocalPathEntry::VarInit)
8113 if (It.Kind == IndirectLocalPathEntry::AddressOf)
8115 if (It.Kind == IndirectLocalPathEntry::LifetimeBoundCall)
8117 return It.Kind == IndirectLocalPathEntry::GslPointerInit ||
8118 It.Kind == IndirectLocalPathEntry::GslReferenceInit;
8126 LifetimeKind LK = LR.getInt();
8131 if (LK == LK_FullExpression)
8134 auto TemporaryVisitor = [&](IndirectLocalPath &Path, Local L,
8135 ReferenceKind RK) ->
bool {
8139 auto *MTE = dyn_cast<MaterializeTemporaryExpr>(L);
8141 bool IsGslPtrInitWithGslTempOwner =
false;
8142 bool IsLocalGslOwner =
false;
8144 if (isa<DeclRefExpr>(L)) {
8150 IsLocalGslOwner = isRecordWithAttr<OwnerAttr>(L->getType());
8154 IsGslPtrInitWithGslTempOwner = MTE && !MTE->getExtendingDecl() &&
8155 isRecordWithAttr<OwnerAttr>(MTE->getType());
8159 if (!IsGslPtrInitWithGslTempOwner)
8165 case LK_FullExpression:
8166 llvm_unreachable(
"already handled this");
8178 if (IsGslPtrInitWithGslTempOwner && DiagLoc.
isValid()) {
8179 Diag(DiagLoc, diag::warn_dangling_lifetime_pointer) << DiagRange;
8184 case PathLifetimeKind::Extend:
8187 MTE->setExtendingDecl(ExtendingEntity->
getDecl(),
8192 case PathLifetimeKind::ShouldExtend:
8199 Diag(DiagLoc, diag::warn_unsupported_lifetime_extension)
8203 case PathLifetimeKind::NoExtend:
8210 Diag(DiagLoc, diag::warn_dangling_variable)
8213 << ExtendingEntity->
getDecl() <<
Init->isGLValue() << DiagRange;
8219 case LK_MemInitializer: {
8220 if (isa<MaterializeTemporaryExpr>(L)) {
8224 if (
auto *ExtendingDecl =
8225 ExtendingEntity ? ExtendingEntity->
getDecl() :
nullptr) {
8226 if (IsGslPtrInitWithGslTempOwner) {
8227 Diag(DiagLoc, diag::warn_dangling_lifetime_pointer_member)
8228 << ExtendingDecl << DiagRange;
8229 Diag(ExtendingDecl->getLocation(),
8230 diag::note_ref_or_ptr_member_declared_here)
8234 bool IsSubobjectMember = ExtendingEntity != &Entity;
8236 PathLifetimeKind::NoExtend
8237 ? diag::err_dangling_member
8238 : diag::warn_dangling_member)
8239 << ExtendingDecl << IsSubobjectMember << RK << DiagRange;
8244 Path.back().Kind != IndirectLocalPathEntry::DefaultInit) {
8245 Diag(ExtendingDecl->getLocation(),
8246 diag::note_lifetime_extending_member_declared_here)
8247 << RK << IsSubobjectMember;
8270 auto *DRE = dyn_cast<DeclRefExpr>(L);
8271 auto *VD = DRE ? dyn_cast<VarDecl>(DRE->getDecl()) :
nullptr;
8279 ExtendingEntity ? ExtendingEntity->
getDecl() :
nullptr) {
8280 bool IsPointer = !
Member->getType()->isReferenceType();
8281 Diag(DiagLoc, IsPointer ? diag::warn_init_ptr_member_to_parameter_addr
8282 : diag::warn_bind_ref_member_to_parameter)
8283 << Member << VD << isa<ParmVarDecl>(VD) << DiagRange;
8285 diag::note_ref_or_ptr_member_declared_here)
8293 if (isa<MaterializeTemporaryExpr>(L)) {
8294 if (IsGslPtrInitWithGslTempOwner)
8295 Diag(DiagLoc, diag::warn_dangling_lifetime_pointer) << DiagRange;
8297 Diag(DiagLoc, RK == RK_ReferenceBinding
8298 ? diag::warn_new_dangling_reference
8299 : diag::warn_new_dangling_initializer_list)
8308 case LK_StmtExprResult:
8309 if (
auto *DRE = dyn_cast<DeclRefExpr>(L)) {
8312 if (LK == LK_StmtExprResult)
8314 Diag(DiagLoc, diag::warn_ret_stack_addr_ref)
8316 << isa<ParmVarDecl>(DRE->getDecl()) << DiagRange;
8317 }
else if (isa<BlockExpr>(L)) {
8318 Diag(DiagLoc, diag::err_ret_local_block) << DiagRange;
8319 }
else if (isa<AddrLabelExpr>(L)) {
8322 if (LK == LK_StmtExprResult)
8324 Diag(DiagLoc, diag::warn_ret_addr_label) << DiagRange;
8325 }
else if (
auto *CLE = dyn_cast<CompoundLiteralExpr>(L)) {
8326 Diag(DiagLoc, diag::warn_ret_stack_addr_ref)
8330 Diag(DiagLoc, diag::warn_ret_local_temp_addr_ref)
8336 for (
unsigned I = 0; I != Path.size(); ++I) {
8337 auto Elem = Path[I];
8339 switch (Elem.Kind) {
8340 case IndirectLocalPathEntry::AddressOf:
8341 case IndirectLocalPathEntry::LValToRVal:
8346 case IndirectLocalPathEntry::LifetimeBoundCall:
8347 case IndirectLocalPathEntry::TemporaryCopy:
8348 case IndirectLocalPathEntry::GslPointerInit:
8349 case IndirectLocalPathEntry::GslReferenceInit:
8353 case IndirectLocalPathEntry::DefaultInit: {
8354 auto *FD = cast<FieldDecl>(Elem.D);
8355 Diag(FD->
getLocation(), diag::note_init_with_default_member_initializer)
8360 case IndirectLocalPathEntry::VarInit: {
8361 const VarDecl *VD = cast<VarDecl>(Elem.D);
8369 case IndirectLocalPathEntry::LambdaCaptureInit:
8370 if (!Elem.Capture->capturesVariable())
8374 const ValueDecl *VD = Elem.Capture->getCapturedVar();
8375 Diag(Elem.Capture->getLocation(), diag::note_lambda_capture_initializer)
8377 << (Elem.Capture->getCaptureKind() ==
LCK_ByRef) << VD
8391 if (
Init->isGLValue())
8394 EnableLifetimeWarnings);
8397 EnableLifetimeWarnings);
8404 const Expr *PostInit);
8411 bool IsReturnStmt) {
8422 unsigned DiagID = 0;
8452 if (VD->
hasAttr<BlocksAttr>())
8465 if (isa<ParmVarDecl>(VD))
8466 DiagID = diag::warn_redundant_move_on_return;
8468 DiagID = diag::warn_pessimizing_move_on_return;
8470 DiagID = diag::warn_pessimizing_move_on_initialization;
8512 if (UO->getOpcode() == UO_Deref &&
8513 UO->getSubExpr()->IgnoreParenCasts()->
8516 S.
PDiag(diag::warn_binding_null_to_reference)
8517 << UO->getSubExpr()->getSourceRange());
8523 bool BoundToLvalueReference) {
8536 Record.ForRangeLifetimeExtendTemps.push_back(MTE);
8568 if (!PointeeTy.isNull() &&
8569 PointeeTy.getAddressSpace() != ExprPointeeTy.getAddressSpace())
8570 CK = CK_AddressSpaceConversion;
8572 CK = CK_AddressSpaceConversion;
8587 if (!ZeroInitializationFixit.empty()) {
8589 const auto *VD = dyn_cast_or_null<VarDecl>(D);
8595 if (!DestType->
isRecordType() && VD && VD->isConstexpr()) {
8597 S.
Diag(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)
8600 ZeroInitializationFixit);
8602 unsigned DiagID = diag::err_default_init_const;
8604 DiagID = diag::ext_default_init_const;
8606 S.
Diag(Kind.getLocation(), DiagID)
8609 ZeroInitializationFixit);
8629 if (isa<InitListExpr>((
Expr *)Args[0])) {
8633 if (
auto *DD = dyn_cast_or_null<DeclaratorDecl>(Entity.
getDecl())) {
8635 TypeLoc TL = TInfo->getTypeLoc();
8638 Brackets = ArrayLoc.getBracketsRange();
8645 ArrayT->getSizeModifier(),
8646 ArrayT->getIndexTypeCVRQualifiers(),
8653 !Kind.isExplicitCast()) {
8655 SourceRange ParenRange = Kind.getParenOrBraceRange();
8660 Kind.isExplicitCast() ||
8670 Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
8676 S.
Diag(
Init->getBeginLoc(), diag::warn_cxx98_compat_reference_list_init)
8677 <<
Init->getSourceRange();
8680 if (S.
getLangOpts().MicrosoftExt && Args.size() == 1 &&
8686 S.
Diag(
Init->getBeginLoc(), diag::ext_init_from_predefined) <<
Init;
8697 S.
Diag(Args[0]->getBeginLoc(), diag::err_opencl_atomic_init)
8717 isa<InitListExpr>(Args[0]);
8718 (void)IsHLSLVectorInit;
8723 switch (Steps.front().Kind) {
8757 assert(Args.size() == 1 || IsHLSLVectorInit);
8776 CurInit.
get() && isa<InitListExpr>(CurInit.
get()));
8781 auto checkAbstractType = [&](
QualType T) ->
bool {
8786 diag::err_allocation_of_abstract_type);
8791 bool ConstructorInitRequiresZeroInit =
false;
8824 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
8836 CK_DerivedToBase, CurInit.
get(),
8852 if (
auto *DRE = dyn_cast<DeclRefExpr>(CurInit.
get()->
IgnoreParens())) {
8853 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
8866 assert(CurInit.
get()->
isPRValue() &&
"not a temporary");
8924 bool CreatedObject =
false;
8940 Loc,
Step->
Type, FoundFn, Constructor, ConstructorArgs,
8941 HadMultipleCandidates,
8953 CastKind = CK_ConstructorConversion;
8954 CreatedObject =
true;
8964 HadMultipleCandidates);
8968 CastKind = CK_UserDefinedConversion;
8972 if (CreatedObject && checkAbstractType(CurInit.
get()->
getType()))
8993 S.
PDiag(diag::err_access_dtor_temp) << T);
9017 "function reference should be lvalue");
9023 assert(CurInit.
get()->
isPRValue() &&
"cannot convert glvalue to atomic");
9031 if (
const auto *FromPtrType =
9034 if (FromPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
9035 !ToPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
9038 if (!Kind.isStaticCast()) {
9040 diag::warn_noderef_to_dereferenceable_pointer)
9060 CurInit = CurInitExprRes;
9081 InitListChecker PerformInitList(S, InitEntity,
9082 InitList, Ty,
false,
9084 if (PerformInitList.HadError())
9092 if ((*ResultType)->isRValueReferenceType())
9094 else if ((*ResultType)->isLValueReferenceType())
9101 PerformInitList.getFullyStructuredList();
9105 : StructuredInitList;
9122 assert(Args.size() == 1 &&
"expected a single argument for list init");
9124 S.
Diag(InitList->
getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
9130 ConstructorInitRequiresZeroInit,
9139 CurInit = cast<InitListExpr>(CurInit.
get())->getInit(0);
9168 bool IsStdInitListInit =
9172 ? Kind.getParenOrBraceRange()
9175 S, UseTemporary ? TempEntity : Entity, Kind,
9177 ConstructorInitRequiresZeroInit,
9188 if (NextStep != StepEnd &&
9193 ConstructorInitRequiresZeroInit =
true;
9196 !Kind.isImplicitValueInit()) {
9200 Kind.getRange().getBegin());
9204 Kind.getRange().getEnd());
9233 CurInit = CurInitExprRes;
9248 S.
Diag(Kind.getLocation(), diag::err_c23_constexpr_pointer_not_null);
9255 InitialCurInit.
get(),
9258 PrintInitLocationNote(S, Entity);
9260 }
else if (Complained)
9261 PrintInitLocationNote(S, Entity);
9277 CK_ObjCObjectLValueCast,
9289 BaseExpr, Kind.getLocation(), IndexExpr, Kind.getLocation());
9290 ArrayLoopCommonExprs.push_back(BaseExpr);
9295 assert(!ArrayLoopCommonExprs.empty() &&
9296 "mismatched SK_ArrayLoopIndex and SK_ArrayLoopInit");
9297 Expr *Common = ArrayLoopCommonExprs.pop_back_val();
9306 S.
Diag(Kind.getLocation(), diag::ext_array_init_copy)
9320 IncompleteDest->getElementType(), ConstantSource->getSize(),
9330 S.
Diag(Kind.getLocation(), diag::ext_array_init_parens)
9350 diag::warn_cxx98_compat_initializer_list_init)
9385 "Sampler initialization on non-sampler type.");
9391 S.
Diag(Kind.getLocation(), diag::err_sampler_argument_required)
9395 auto Var = cast<VarDecl>(DRE->getDecl());
9398 if (!Var->hasGlobalStorage()) {
9410 if (!Var->getInit() || !isa<ImplicitCastExpr>(Var->getInit()))
9412 Init = cast<ImplicitCastExpr>(
const_cast<Expr*
>(
9413 Var->getInit()))->getSubExpr();
9414 SourceType =
Init->getType();
9421 if (!
Init->isConstantInitializer(S.
Context,
false))
9426 S.
Diag(Kind.getLocation(), diag::err_sampler_initializer_not_integer)
9434 const uint64_t SamplerValue =
Result.getLimitedValue();
9441 unsigned AddressingMode = (0x0E & SamplerValue) >> 1;
9442 unsigned FilterMode = (0x30 & SamplerValue) >> 4;
9443 if (FilterMode != 1 && FilterMode != 2 &&
9445 "cl_intel_device_side_avc_motion_estimation", S.
getLangOpts()))
9446 S.
Diag(Kind.getLocation(),
9447 diag::warn_sampler_initializer_invalid_bits)
9449 if (AddressingMode > 4)
9450 S.
Diag(Kind.getLocation(),
9451 diag::warn_sampler_initializer_invalid_bits)
9452 <<
"Addressing Mode";
9458 CK_IntToOCLSampler);
9464 "Wrong type for initialization of OpenCL opaque type.");
9467 CK_ZeroToOCLOpaqueType,
9475 if (CurInit.
get() && ResultType)
9496 cast<FieldDecl>(Entity.
getDecl())->isBitField())
9497 S.CheckBitFieldInitialization(Kind.getLocation(),
9512 S.
Diag(Loc, diag::err_reference_without_init)
9521 for (
const auto *FI : RD->
fields()) {
9522 if (FI->isUnnamedBitfield())
9526 S.
Diag(Loc, diag::note_value_initialization_here) << RD;
9531 for (
const auto &BI : RD->
bases()) {
9533 S.
Diag(Loc, diag::note_value_initialization_here) << RD;
9568 if (fromDecl && destDecl && fromDecl->getDeclKind() == Decl::CXXRecord &&
9569 destDecl->getDeclKind() == Decl::CXXRecord &&
9570 !fromDecl->isInvalidDecl() && !destDecl->isInvalidDecl() &&
9571 !fromDecl->hasDefinition() &&
9574 S.
Diag(fromDecl->getLocation(), diag::note_forward_class_conversion)
9602 if (
auto *D = Entity.
getDecl())
9603 Loc = D->getLocation();
9604 S.
Diag(Loc, diag::note_in_reference_temporary_list_initializer) << T;
9608 InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
9611 assert(DiagnoseInitList.HadError() &&
9612 "Inconsistent init list check result.");
9625 if (Args.size() == 1) {
9626 auto *List = dyn_cast<InitListExpr>(Args[0]);
9627 if (List && List->getNumInits() == 1)
9628 OnlyArg = List->getInit(0);
9647 assert(Diagnosed &&
"couldn't find uninitialized reference to diagnose");
9650 S.
Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
9651 <<
SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
9654 S.
Diag(Kind.getLocation(), diag::err_list_init_in_parens)
9655 << 1 << Entity.
getType() << Args[0]->getSourceRange();
9659 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
9662 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
9665 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
9668 S.
Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
9671 S.
Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
9674 S.
Diag(Kind.getLocation(),
9675 diag::err_array_init_incompat_wide_string_into_wchar);
9678 S.
Diag(Kind.getLocation(),
9679 diag::err_array_init_plain_string_into_char8_t);
9680 S.
Diag(Args.front()->getBeginLoc(),
9681 diag::note_array_init_plain_string_into_char8_t)
9685 S.
Diag(Kind.getLocation(), diag::err_array_init_utf8_string_into_char)
9690 S.
Diag(Kind.getLocation(),
9692 ? diag::err_array_init_different_type
9693 : diag::err_array_init_non_constant_array))
9696 << Args[0]->getSourceRange();
9700 S.
Diag(Kind.getLocation(), diag::err_variable_object_no_init)
9701 << Args[0]->getSourceRange();
9714 auto *FD = cast<FunctionDecl>(cast<DeclRefExpr>(OnlyArg)->getDecl());
9722 switch (FailedOverloadResult) {
9729 ? (S.
PDiag(diag::err_typecheck_ambiguous_condition)
9730 << OnlyArg->
getType() << DestType
9731 << Args[0]->getSourceRange())
9732 : (S.
PDiag(diag::err_ref_init_ambiguous)
9733 << DestType << OnlyArg->
getType()
9734 << Args[0]->getSourceRange())),
9742 diag::err_typecheck_nonviable_condition_incomplete,
9743 OnlyArg->
getType(), Args[0]->getSourceRange()))
9744 S.
Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
9746 << OnlyArg->
getType() << Args[0]->getSourceRange()
9753 S.
Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
9755 << Args[0]->getSourceRange();
9762 llvm_unreachable(
"Inconsistent overload resolution?");
9768 llvm_unreachable(
"Conversion did not fail!");
9773 if (isa<InitListExpr>(Args[0])) {
9774 S.
Diag(Kind.getLocation(),
9775 diag::err_lvalue_reference_bind_to_initlist)
9778 << Args[0]->getSourceRange();
9784 S.
Diag(Kind.getLocation(),
9786 ? diag::err_lvalue_reference_bind_to_temporary
9787 : diag::err_lvalue_reference_bind_to_unrelated)
9791 << Args[0]->getSourceRange();
9796 FieldDecl *BitField = Args[0]->getSourceBitField();
9797 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
9800 << (BitField !=
nullptr)
9801 << Args[0]->getSourceRange();
9808 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
9810 << Args[0]->getSourceRange();
9814 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_matrix_element)
9819 S.
Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
9821 << Args[0]->getSourceRange();
9825 S.
Diag(Kind.getLocation(), diag::err_reference_bind_temporary_addrspace)
9826 << DestType << Args[0]->getSourceRange();
9837 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
9838 << NonRefType << SourceType << 1
9839 << Args[0]->getSourceRange();
9841 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
9842 << NonRefType << SourceType << 0
9848 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
9849 << NonRefType << SourceType << 2
9850 << Args[0]->getSourceRange();
9855 S.
Diag(Kind.getLocation(), diag::err_reference_bind_failed)
9860 << Args[0]->getSourceRange();
9871 << Args[0]->getSourceRange();
9873 S.
Diag(Kind.getLocation(), PDiag);
9885 auto *InitList = dyn_cast<InitListExpr>(Args[0]);
9886 if (InitList && InitList->getNumInits() >= 1) {
9887 R =
SourceRange(InitList->getInit(0)->getEndLoc(), InitList->getEndLoc());
9889 assert(Args.size() > 1 &&
"Expected multiple initializers!");
9890 R =
SourceRange(Args.front()->getEndLoc(), Args.back()->getEndLoc());
9894 if (Kind.isCStyleOrFunctionalCast())
9895 S.
Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
9898 S.
Diag(Kind.getLocation(), diag::err_excess_initializers)
9904 S.
Diag(Kind.getLocation(), diag::err_list_init_in_parens)
9905 << 0 << Entity.
getType() << Args[0]->getSourceRange();
9909 S.
Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
9914 S.
Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
9915 << (DestType->
isRecordType()) << DestType << Args[0]->getSourceRange();
9923 SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
9926 assert(Args.size() == 1 &&
9927 "List construction from other than 1 argument.");
9934 switch (FailedOverloadResult) {
9938 S.
PDiag(diag::err_ovl_ambiguous_init)
9939 << DestType << ArgsRange),
9956 if (
auto Inherited = Constructor->getInheritedConstructor())
9957 InheritedFrom = Inherited.getShadowDecl()->getNominatedBaseClass();
9959 S.
Diag(Kind.getLocation(), diag::err_missing_default_ctor)
9960 << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
9972 S.
Diag(Kind.getLocation(), diag::err_missing_default_ctor)
9973 << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
9979 diag::note_member_declared_at);
9984 diag::note_previous_decl)
9993 S.
PDiag(diag::err_ovl_no_viable_function_in_init)
9994 << DestType << ArgsRange),
10003 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
10004 << DestType << ArgsRange;
10005 llvm_unreachable(
"Inconsistent overload resolution?");
10013 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
10015 << DestType << ArgsRange;
10017 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
10018 << DestType << ArgsRange;
10025 llvm_unreachable(
"Conversion did not fail!");
10037 S.
Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
10038 << (Constructor->getInheritedConstructor() ? 2 :
10039 Constructor->isImplicit() ? 1 : 0)
10045 }
else if (
const auto *VD = dyn_cast_if_present<VarDecl>(Entity.
getDecl());
10046 VD && VD->isConstexpr()) {
10047 S.
Diag(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)
10050 S.
Diag(Kind.getLocation(), diag::err_default_init_const)
10057 diag::err_init_incomplete_type);
10073 S.
Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
10074 << Args[0]->getSourceRange();
10079 assert(Ovl ==
OR_Success &&
"Inconsistent overload resolution");
10082 diag::note_explicit_ctor_deduction_guide_here) <<
false;
10093 S.
Diag(Kind.getLocation(), diag::err_designated_init_for_non_aggregate)
10098 PrintInitLocationNote(S, Entity);
10105 OS <<
"Failed sequence: ";
10108 OS <<
"too many initializers for reference";
10112 OS <<
"parenthesized list init for reference";
10116 OS <<
"array requires initializer list";
10120 OS <<
"address of unaddressable function was taken";
10124 OS <<
"array requires initializer list or string literal";
10128 OS <<
"array requires initializer list or wide string literal";
10132 OS <<
"narrow string into wide char array";
10136 OS <<
"wide string into char array";
10140 OS <<
"incompatible wide string into wide char array";
10144 OS <<
"plain string literal into char8_t array";
10148 OS <<
"u8 string literal into char array";
10152 OS <<
"array type mismatch";
10156 OS <<
"non-constant array initializer";
10160 OS <<
"address of overloaded function failed";
10164 OS <<
"overload resolution for reference initialization failed";
10168 OS <<
"non-const lvalue reference bound to temporary";
10172 OS <<
"non-const lvalue reference bound to bit-field";
10176 OS <<
"non-const lvalue reference bound to vector element";
10180 OS <<
"non-const lvalue reference bound to matrix element";
10184 OS <<
"non-const lvalue reference bound to unrelated type";
10188 OS <<
"rvalue reference bound to an lvalue";
10192 OS <<
"reference initialization drops qualifiers";
10196 OS <<
"reference with mismatching address space bound to temporary";
10200 OS <<
"reference initialization failed";
10204 OS <<
"conversion failed";
10208 OS <<
"conversion from property failed";
10212 OS <<
"too many initializers for scalar";
10216 OS <<
"parenthesized list init for reference";
10220 OS <<
"referencing binding to initializer list";
10224 OS <<
"initializer list for non-aggregate, non-scalar type";
10228 OS <<
"overloading failed for user-defined conversion";
10232 OS <<
"constructor overloading failed";
10236 OS <<
"default initialization of a const variable";
10240 OS <<
"initialization of incomplete type";
10244 OS <<
"list initialization checker failure";
10248 OS <<
"variable length array has an initializer";
10252 OS <<
"initializer expression isn't contextually valid";
10256 OS <<
"list constructor overloading failed";
10260 OS <<
"list copy initialization chose explicit constructor";
10264 OS <<
"parenthesized list initialization failed";
10268 OS <<
"designated initializer for non-aggregate type";
10276 OS <<
"Dependent sequence\n";
10280 OS <<
"Normal sequence: ";
10291 OS <<
"resolve address of overloaded function";
10295 OS <<
"derived-to-base (prvalue)";
10299 OS <<
"derived-to-base (xvalue)";
10303 OS <<
"derived-to-base (lvalue)";
10307 OS <<
"bind reference to lvalue";
10311 OS <<
"bind reference to a temporary";
10315 OS <<
"final copy in class direct-initialization";
10319 OS <<
"extraneous C++03 copy to temporary";
10323 OS <<
"user-defined conversion via " << *S->Function.Function;
10327 OS <<
"qualification conversion (prvalue)";
10331 OS <<
"qualification conversion (xvalue)";
10335 OS <<
"qualification conversion (lvalue)";
10339 OS <<
"function reference conversion";
10343 OS <<
"non-atomic-to-atomic conversion";
10347 OS <<
"implicit conversion sequence (";
10353 OS <<
"implicit conversion sequence with narrowing prohibited (";
10359 OS <<
"list aggregate initialization";
10363 OS <<
"unwrap reference initializer list";
10367 OS <<
"rewrap reference initializer list";
10371 OS <<
"constructor initialization";
10375 OS <<
"list initialization via constructor";
10379 OS <<
"zero initialization";
10383 OS <<
"C assignment";
10387 OS <<
"string initialization";
10391 OS <<
"Objective-C object conversion";
10395 OS <<
"indexing for array initialization loop";
10399 OS <<
"array initialization loop";
10403 OS <<
"array initialization";
10407 OS <<
"array initialization (GNU extension)";
10411 OS <<
"parenthesized array initialization";
10415 OS <<
"pass by indirect copy and restore";
10419 OS <<
"pass by indirect restore";
10423 OS <<
"Objective-C object retension";
10427 OS <<
"std::initializer_list from initializer list";
10431 OS <<
"list initialization from std::initializer_list";
10435 OS <<
"OpenCL sampler_t from integer constant";
10439 OS <<
"OpenCL opaque type from zero";
10442 OS <<
"initialization from a parenthesized list of values";
10446 OS <<
" [" << S->Type <<
']';
10453 dump(llvm::errs());
10460 const Expr *PostInit) {
10476 auto MakeDiag = [&](
bool IsConstRef,
unsigned DefaultDiagID,
10477 unsigned ConstRefDiagID,
unsigned WarnDiagID) {
10480 if (L.CPlusPlus11 &&
10482 DiagID = IsConstRef ? ConstRefDiagID : DefaultDiagID;
10484 DiagID = WarnDiagID;
10504 MakeDiag(T != EntityType, diag::ext_init_list_type_narrowing,
10505 diag::ext_init_list_type_narrowing_const_reference,
10506 diag::warn_init_list_type_narrowing)
10515 diag::ext_init_list_constant_narrowing,
10516 diag::ext_init_list_constant_narrowing_const_reference,
10517 diag::warn_init_list_constant_narrowing)
10526 diag::ext_init_list_variable_narrowing,
10527 diag::ext_init_list_variable_narrowing_const_reference,
10528 diag::warn_init_list_variable_narrowing)
10536 llvm::raw_svector_ostream OS(StaticCast);
10537 OS <<
"static_cast<";
10544 OS << *TT->getDecl();
10553 S.
Diag(PostInit->
getBeginLoc(), diag::note_init_list_narrowing_silence)
10564 Init->IgnoreParenImpCasts(), ToType,
false,
10565 Sema::AllowedExplicit::None,
10581 S.
Diag(
Init->getBeginLoc(), diag::err_c23_constexpr_init_not_representable)
10582 <<
Value.getAsString(S.
Context, PreNarrowingType) << ToType;
10587 S.
Diag(
Init->getBeginLoc(), diag::err_c23_constexpr_init_type_mismatch)
10588 << ToType << FromType;
10598 llvm_unreachable(
"unhandled case in switch");
10610 for (
unsigned I = 0, N = SE->
getLength(); I != N; ++I) {
10615 diag::err_c23_constexpr_init_not_representable)
10629 if (
Init.isInvalid())
10633 assert(InitE &&
"No initialization expression");
10638 return !
Seq.Failed();
10645 bool TopLevelOfInitList,
10646 bool AllowExplicit) {
10647 if (
Init.isInvalid())
10651 assert(InitE &&
"No initialization expression?");
10661 const bool ShouldTrackCopy =
10663 if (ShouldTrackCopy) {
10665 Seq.SetOverloadFailure(
10671 const auto LastStep =
Seq.step_end() - 1;
10672 assert(LastStep->Kind ==
10676 llvm::find_if(
Seq.getFailedCandidateSet(),
10678 return Candidate.Viable &&
10679 Candidate.Function == Function &&
10680 Candidate.Conversions.size() > 0;
10682 if (Candidate !=
Seq.getFailedCandidateSet().end() &&
10684 Candidate->
Viable =
false;
10688 Function->getParamDecl(0)->getType());
10696 if (ShouldTrackCopy)
10705 auto NotSpecialization = [&] (
const CXXRecordDecl *Candidate) {
10706 auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Candidate);
10709 return !(NotSpecialization(RD) && RD->
forallBases(NotSpecialization));
10715 auto *DeducedTST = dyn_cast<DeducedTemplateSpecializationType>(
10717 assert(DeducedTST &&
"not a deduced template specialization type");
10728 if (
auto *
AliasTemplate = dyn_cast_or_null<TypeAliasTemplateDecl>(
10730 Diag(Kind.getLocation(),
10731 diag::warn_cxx17_compat_ctad_for_alias_templates);
10734 ->getUnderlyingType()
10735 .getCanonicalType();
10739 if (
const auto *TST =
10741 Template = dyn_cast_or_null<ClassTemplateDecl>(
10742 TST->getTemplateName().getAsTemplateDecl());
10743 }
else if (
const auto *RT = UnderlyingType->getAs<
RecordType>()) {
10747 if (
const auto *CTSD = llvm::dyn_cast<ClassTemplateSpecializationDecl>(
10748 RT->getAsCXXRecordDecl()))
10749 Template = CTSD->getSpecializedTemplate();
10754 Diag(Kind.getLocation(),
10755 diag::err_deduced_non_class_or_alias_template_specialization_type)
10765 diag::warn_cxx14_compat_class_template_argument_deduction)
10795 ? dyn_cast<InitListExpr>(Inits[0])
10811 bool AllowExplicit = !Kind.isCopyInit() ||
ListInit;
10817 bool OnlyListConstructors,
10818 bool AllowAggregateDeductionCandidate) {
10824 if (!AllowExplicit) {
10831 if (GD->getMinRequiredArguments() > 1 ||
10832 (GD->getNumParams() == 0 && !GD->isVariadic()))
10842 if (!AllowAggregateDeductionCandidate &&
10858 bool SuppressUserConversions = Kind.isCopyInit();
10862 for (
Expr *E : Inits)
10863 if (
auto *DI = dyn_cast<DesignatedInitExpr>(E))
10864 TmpInits.push_back(DI->getInit());
10866 TmpInits.push_back(E);
10868 TD, FoundDecl,
nullptr, TmpInits, Candidates,
10869 SuppressUserConversions,
10870 false, AllowExplicit, ADLCallKind::NotADL,
10871 {}, AllowAggregateDeductionCandidate);
10874 SuppressUserConversions,
10875 false, AllowExplicit);
10879 bool FoundDeductionGuide =
false;
10881 auto TryToResolveOverload =
10884 bool HasAnyDeductionGuide =
false;
10887 auto *Pattern = Template;
10888 while (Pattern->getInstantiatedFromMemberTemplate()) {
10889 if (Pattern->isMemberSpecialization())
10891 Pattern = Pattern->getInstantiatedFromMemberTemplate();
10894 auto *RD = cast<CXXRecordDecl>(Pattern->getTemplatedDecl());
10900 InitListChecker CheckInitList(*
this, Entity,
ListInit, Ty, ElementTypes);
10901 if (!CheckInitList.HadError()) {
10910 for (
int I = 0, E =
ListInit->getNumInits();
10911 I < E && !isa<PackExpansionType>(ElementTypes[I]); ++I)
10912 if (ElementTypes[I]->isArrayType()) {
10913 if (isa<InitListExpr>(
ListInit->getInit(I)))
10915 else if (isa<StringLiteral>(
10916 ListInit->getInit(I)->IgnoreParenImpCasts()))
10921 llvm::FoldingSetNodeID ID;
10922 ID.AddPointer(Template);
10923 for (
auto &T : ElementTypes)
10924 T.getCanonicalType().
Profile(ID);
10925 unsigned Hash = ID.ComputeHash();
10929 Template, ElementTypes,
10935 OnlyListConstructors,
10941 assert(TD &&
"aggregate deduction candidate is function template");
10943 OnlyListConstructors,
10946 HasAnyDeductionGuide =
true;
10950 for (
auto I = Guides.
begin(), E = Guides.
end(); I != E; ++I) {
10951 NamedDecl *D = (*I)->getUnderlyingDecl();
10955 auto *TD = dyn_cast<FunctionTemplateDecl>(D);
10956 auto *GD = dyn_cast_if_present<CXXDeductionGuideDecl>(
10961 if (!GD->isImplicit())
10962 HasAnyDeductionGuide =
true;
10964 addDeductionCandidate(TD, GD, I.getPair(), OnlyListConstructors,
10979 }
else if (Inits.size()) {
10984 Inits, Inits.back()->getEndLoc());
10985 SynthesizeAggrGuide(&TempListInit);
10989 FoundDeductionGuide = FoundDeductionGuide || HasAnyDeductionGuide;
10999 bool TryListConstructors =
true;
11005 auto *FD = dyn_cast<FunctionDecl>(D->getUnderlyingDecl());
11006 if (FD && FD->getMinRequiredArguments() == 0) {
11007 TryListConstructors =
false;
11011 }
else if (
ListInit->getNumInits() == 1) {
11019 if (!isa<InitListExpr>(E) && RD &&
11022 TryListConstructors =
false;
11025 if (TryListConstructors)
11026 Result = TryToResolveOverload(
true);
11035 Result = TryToResolveOverload(
false);
11044 Kind.getLocation(),
11045 PDiag(diag::err_deduced_class_template_ctor_ambiguous)
11052 cast<ClassTemplateDecl>(Template)->getTemplatedDecl();
11057 Kind.getLocation(),
11058 PDiag(
Complete ? diag::err_deduced_class_template_ctor_no_viable
11059 : diag::err_deduced_class_template_incomplete)
11066 Diag(Kind.getLocation(), diag::err_deduced_class_template_deleted)
11076 if (Kind.isCopyInit() &&
ListInit &&
11077 cast<CXXDeductionGuideDecl>(Best->Function)->isExplicit()) {
11078 bool IsDeductionGuide = !Best->Function->isImplicit();
11079 Diag(Kind.getLocation(), diag::err_deduced_class_template_explicit)
11081 Diag(Best->Function->getLocation(),
11082 diag::note_explicit_ctor_deduction_guide_here)
11083 << IsDeductionGuide;
11100 diag::warn_cxx14_compat_class_template_argument_deduction)
11105 if (!FoundDeductionGuide) {
11107 diag::warn_ctad_maybe_unsupported)
11109 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.
const llvm::APInt & getSize() const
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
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.
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
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
Sema - This implements semantic analysis and AST building for C.
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
CXXSpecialMember 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)
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
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...
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()
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CCK_ImplicitConversion)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
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)
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.
FunctionTemplateDecl * DeclareImplicitDeductionGuideFromInitList(TemplateDecl *Template, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc)
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
CXXConstructorDecl * LookupDefaultConstructor(CXXRecordDecl *Class)
Look up the default constructor for the given class.
const LangOptions & getLangOpts() const
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
void EmitRelatedResultTypeNoteForReturn(QualType destType)
Given that we had incompatible pointer types in a return statement, check whether we're in a method w...
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
llvm::DenseMap< unsigned, CXXDeductionGuideDecl * > AggregateDeductionCandidates
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.
ExprResult PerformQualificationConversion(Expr *E, QualType Ty, ExprValueKind VK=VK_PRValue, CheckedConversionKind CCK=CCK_ImplicitConversion)
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...
CheckedConversionKind
The kind of conversion being performed.
@ CCK_OtherCast
A cast other than a C-style cast.
@ CCK_CStyleCast
A C-style cast.
@ CCK_ImplicitConversion
An implicit conversion.
@ CCK_FunctionalCast
A functional-style cast.
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...
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
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 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
void Profile(llvm::FoldingSetNodeID &ID)
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)
@ 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.
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.