32#include "llvm/ADT/APInt.h"
33#include "llvm/ADT/FoldingSet.h"
34#include "llvm/ADT/PointerIntPair.h"
35#include "llvm/ADT/STLForwardCompat.h"
36#include "llvm/ADT/SmallString.h"
37#include "llvm/ADT/SmallVector.h"
38#include "llvm/ADT/StringExtras.h"
39#include "llvm/Support/ErrorHandling.h"
40#include "llvm/Support/raw_ostream.h"
76 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
94 auto IsCharOrUnsignedChar = [](
const QualType &
T) {
95 const BuiltinType *BT = dyn_cast<BuiltinType>(
T.getTypePtr());
100 case StringLiteralKind::UTF8:
110 case StringLiteralKind::Ordinary:
114 return (SL->
getKind() == StringLiteralKind::UTF8 &&
128 case StringLiteralKind::UTF16:
136 case StringLiteralKind::UTF32:
144 case StringLiteralKind::Wide:
152 case StringLiteralKind::Unevaluated:
153 assert(
false &&
"Unevaluated string literal in initialization");
157 llvm_unreachable(
"missed a StringLiteral kind?");
178 if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
189 if (isa<CompoundLiteralExpr>(E))
204 if (
const auto *VD = dyn_cast_if_present<VarDecl>(D); VD && VD->isConstexpr())
214 Sema &S,
bool CheckC23ConstexprInit =
false) {
216 auto *ConstantArrayTy =
218 uint64_t StrLength = ConstantArrayTy->getZExtSize();
220 if (CheckC23ConstexprInit)
227 llvm::APInt ConstVal(32, StrLength);
253 diag::err_initializer_string_for_char_array_too_long)
259 diag::ext_initializer_string_for_char_array_too_long)
307class InitListChecker {
309 bool hadError =
false;
311 bool TreatUnavailableAsInvalid;
312 bool InOverloadResolution;
326 unsigned &StructuredIndex);
330 bool TopLevelObject =
false);
333 bool SubobjectIsDesignatorContext,
336 unsigned &StructuredIndex,
337 bool TopLevelObject =
false);
342 unsigned &StructuredIndex,
343 bool DirectlyDesignated =
false);
348 unsigned &StructuredIndex);
353 unsigned &StructuredIndex);
358 unsigned &StructuredIndex);
362 unsigned &StructuredIndex);
367 bool SubobjectIsDesignatorContext,
unsigned &Index,
369 unsigned &StructuredIndex,
370 bool TopLevelObject =
false);
373 llvm::APSInt elementIndex,
374 bool SubobjectIsDesignatorContext,
unsigned &Index,
376 unsigned &StructuredIndex);
382 llvm::APSInt *NextElementIndex,
385 unsigned &StructuredIndex,
386 bool FinishSubobjectInit,
387 bool TopLevelObject);
391 unsigned StructuredIndex,
393 bool IsFullyOverwritten =
false);
394 void UpdateStructuredListElement(
InitListExpr *StructuredList,
395 unsigned &StructuredIndex,
399 unsigned ExpectedNumInits);
400 int numArrayElements(
QualType DeclType);
401 int numStructUnionElements(
QualType DeclType);
409 bool UnionOverride =
false,
410 bool FullyOverwritten =
true) {
415 ? (UnionOverride ? diag::ext_initializer_union_overrides
416 : diag::ext_initializer_overrides)
417 : diag::warn_initializer_overrides;
419 if (InOverloadResolution && SemaRef.
getLangOpts().CPlusPlus) {
440 DiagID = diag::err_initializer_overrides_destructed;
460 << NewInitRange << FullyOverwritten << OldInit->
getType();
489 bool FillWithNoInit);
490 void FillInEmptyInitForField(
unsigned Init,
FieldDecl *Field,
493 bool FillWithNoInit =
false);
497 bool FillWithNoInit =
false);
500 bool TopLevelObject);
507 bool VerifyOnly,
bool TreatUnavailableAsInvalid,
508 bool InOverloadResolution =
false,
513 : InitListChecker(S, Entity, IL,
T,
true,
516 &AggrDeductionCandidateParamTypes){};
518 bool HadError() {
return hadError; }
522 InitListExpr *getFullyStructuredList()
const {
return FullyStructuredList; }
539 bool EmptyInitList = SemaRef.
getLangOpts().CPlusPlus11 &&
552 InitExpr = VerifyOnly
570 if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
574 InitSeq.getFailedCandidateSet()
575 .BestViableFunction(SemaRef,
Kind.getLocation(), Best);
577 assert(O ==
OR_Success &&
"Inconsistent overload resolution");
584 bool IsInStd =
false;
586 ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
591 if (IsInStd && llvm::StringSwitch<bool>(R->
getName())
592 .Cases(
"basic_string",
"deque",
"forward_list",
true)
593 .Cases(
"list",
"map",
"multimap",
"multiset",
true)
594 .Cases(
"priority_queue",
"queue",
"set",
"stack",
true)
595 .Cases(
"unordered_map",
"unordered_set",
"vector",
true)
597 InitSeq.InitializeFrom(
601 TreatUnavailableAsInvalid);
606 diag::warn_invalid_initializer_from_system_header);
609 diag::note_used_in_initialization_here);
611 SemaRef.
Diag(
Loc, diag::note_used_in_initialization_here);
618 InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
621 diag::note_in_omitted_aggregate_initializer)
624 bool IsTrailingArrayNewMember =
627 SemaRef.
Diag(
Loc, diag::note_in_omitted_aggregate_initializer)
628 << (IsTrailingArrayNewMember ? 2 : 0)
637 : InitSeq.Perform(SemaRef, Entity,
Kind, SubInit);
645 if (FullyStructuredList)
647 PerformEmptyInit(
Loc, Entity);
650void InitListChecker::FillInEmptyInitForBase(
653 bool &RequiresSecondPass,
bool FillWithNoInit) {
660 : PerformEmptyInit(ILE->
getEndLoc(), BaseEntity);
667 assert(Init < ILE->getNumInits() &&
"should have been expanded");
672 FillInEmptyInitializations(BaseEntity, InnerILE, RequiresSecondPass,
673 ILE,
Init, FillWithNoInit);
675 dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(
Init))) {
676 FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),
677 RequiresSecondPass, ILE,
Init,
682void InitListChecker::FillInEmptyInitForField(
unsigned Init,
FieldDecl *Field,
685 bool &RequiresSecondPass,
686 bool FillWithNoInit) {
694 if (!RType->getDecl()->isUnion())
695 assert((
Init < NumInits || VerifyOnly) &&
696 "This ILE should have been expanded");
698 if (FillWithNoInit) {
699 assert(!VerifyOnly &&
"should not fill with no-init in verify-only mode");
711 if (
Field->hasInClassInitializer()) {
725 RequiresSecondPass =
true;
730 if (
Field->getType()->isReferenceType()) {
736 SemaRef.
Diag(
Loc, diag::err_init_reference_member_uninitialized)
740 SemaRef.
Diag(
Field->getLocation(), diag::note_uninit_reference_member);
752 if (hadError || VerifyOnly) {
754 }
else if (
Init < NumInits) {
756 }
else if (!isa<ImplicitValueInitExpr>(MemberInit.
get())) {
762 RequiresSecondPass =
true;
766 FillInEmptyInitializations(MemberEntity, InnerILE,
767 RequiresSecondPass, ILE,
Init, FillWithNoInit);
769 dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(
Init))) {
770 FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
771 RequiresSecondPass, ILE,
Init,
782 bool &RequiresSecondPass,
785 bool FillWithNoInit) {
787 "Should not have void type");
791 if (FillWithNoInit && VerifyOnly)
801 struct UpdateOuterILEWithUpdatedInit {
804 ~UpdateOuterILEWithUpdatedInit() {
808 } UpdateOuterRAII = {OuterILE, OuterIndex};
819 Entity, ILE, RequiresSecondPass, FillWithNoInit);
820 else if (RDecl->
isUnion() && isa<CXXRecordDecl>(RDecl) &&
821 cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
822 for (
auto *Field : RDecl->
fields()) {
823 if (
Field->hasInClassInitializer()) {
824 FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass,
833 unsigned NumElems = numStructUnionElements(ILE->
getType());
841 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {
842 for (
auto &
Base : CXXRD->bases()) {
846 FillInEmptyInitForBase(
Init,
Base, Entity, ILE, RequiresSecondPass,
852 for (
auto *Field : RDecl->
fields()) {
853 if (
Field->isUnnamedBitField())
859 FillInEmptyInitForField(
Init, Field, Entity, ILE, RequiresSecondPass,
881 ElementType = AType->getElementType();
882 if (
const auto *CAType = dyn_cast<ConstantArrayType>(AType))
883 NumElements = CAType->getZExtSize();
891 ElementType = VType->getElementType();
892 NumElements = VType->getNumElements();
898 bool SkipEmptyInitChecks =
false;
911 if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
916 if (SkipEmptyInitChecks)
919 Expr *Filler =
nullptr;
925 PerformEmptyInit(ILE->
getEndLoc(), ElementEntity);
936 }
else if (VerifyOnly) {
937 SkipEmptyInitChecks =
true;
938 }
else if (
Init < NumInits) {
953 if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {
959 RequiresSecondPass =
true;
963 = dyn_cast_or_null<InitListExpr>(InitExpr)) {
964 FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
965 ILE,
Init, FillWithNoInit);
967 dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr)) {
968 FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
969 RequiresSecondPass, ILE,
Init,
977 if (isa_and_nonnull<DesignatedInitExpr>(
Init))
982InitListChecker::InitListChecker(
984 bool VerifyOnly,
bool TreatUnavailableAsInvalid,
bool InOverloadResolution,
986 : SemaRef(S), VerifyOnly(VerifyOnly),
987 TreatUnavailableAsInvalid(TreatUnavailableAsInvalid),
988 InOverloadResolution(InOverloadResolution),
989 AggrDeductionCandidateParamTypes(AggrDeductionCandidateParamTypes) {
991 FullyStructuredList =
1000 CheckExplicitInitList(Entity, IL,
T, FullyStructuredList,
1003 if (!hadError && !AggrDeductionCandidateParamTypes && FullyStructuredList) {
1004 bool RequiresSecondPass =
false;
1005 FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass,
1007 if (RequiresSecondPass && !hadError)
1008 FillInEmptyInitializations(Entity, FullyStructuredList,
1009 RequiresSecondPass,
nullptr, 0);
1011 if (hadError && FullyStructuredList)
1015int InitListChecker::numArrayElements(
QualType DeclType) {
1017 int maxElements = 0x7FFFFFFF;
1020 maxElements =
static_cast<int>(CAT->getZExtSize());
1025int InitListChecker::numStructUnionElements(
QualType DeclType) {
1027 int InitializableMembers = 0;
1028 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl))
1029 InitializableMembers += CXXRD->getNumBases();
1030 for (
const auto *Field : structDecl->
fields())
1031 if (!
Field->isUnnamedBitField())
1032 ++InitializableMembers;
1035 return std::min(InitializableMembers, 1);
1041 return RT->getDecl();
1043 return Inject->getDecl();
1073 if (
CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(ParentRD)) {
1074 if (CXXRD->getNumBases()) {
1078 auto FieldIt = ParentRD->field_begin();
1079 assert(FieldIt != ParentRD->field_end() &&
1080 "no fields but have initializer for member?");
1081 return ++FieldIt == ParentRD->field_end();
1097 unsigned &StructuredIndex) {
1098 int maxElements = 0;
1101 maxElements = numArrayElements(
T);
1103 maxElements = numStructUnionElements(
T);
1107 llvm_unreachable(
"CheckImplicitInitList(): Illegal type");
1109 if (maxElements == 0) {
1112 diag::err_implicit_empty_initializer);
1119 InitListExpr *StructuredSubobjectInitList = getStructuredSubobjectInit(
1120 ParentIList, Index,
T, StructuredList, StructuredIndex,
1123 unsigned StructuredSubobjectInitIndex = 0;
1126 unsigned StartIndex = Index;
1127 CheckListElementTypes(Entity, ParentIList,
T,
1129 StructuredSubobjectInitList,
1130 StructuredSubobjectInitIndex);
1132 if (StructuredSubobjectInitList) {
1133 StructuredSubobjectInitList->
setType(
T);
1135 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
1138 if (EndIndex < ParentIList->getNumInits() &&
1139 ParentIList->
getInit(EndIndex)) {
1150 diag::warn_missing_braces)
1156 StructuredSubobjectInitList->
getEndLoc()),
1162 if (!VerifyOnly && CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1164 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1180 unsigned DiagID = 0;
1192 DiagID = diag::warn_braces_around_init;
1199 DiagID = diag::warn_braces_around_init;
1225 llvm_unreachable(
"unexpected braced scalar init");
1244 bool TopLevelObject) {
1245 unsigned Index = 0, StructuredIndex = 0;
1246 CheckListElementTypes(Entity, IList,
T,
true,
1247 Index, StructuredList, StructuredIndex, TopLevelObject);
1248 if (StructuredList) {
1254 StructuredList->
setType(ExprTy);
1262 bool ExtraInitsIsError = SemaRef.
getLangOpts().CPlusPlus ||
1264 hadError = ExtraInitsIsError;
1267 }
else if (StructuredIndex == 1 &&
1272 ? diag::err_excess_initializers_in_char_array_initializer
1273 : diag::ext_excess_initializers_in_char_array_initializer;
1277 unsigned DK = ExtraInitsIsError
1278 ? diag::err_excess_initializers_for_sizeless_type
1279 : diag::ext_excess_initializers_for_sizeless_type;
1289 unsigned DK = ExtraInitsIsError ? diag::err_excess_initializers
1290 : diag::ext_excess_initializers;
1298 !isa<InitListExpr>(IList->
getInit(0)))
1304 if (CXXRD && CXXRD->hasUserDeclaredConstructor()) {
1307 bool HasEquivCtor =
false;
1313 if (!HasEquivCtor) {
1315 diag::warn_cxx20_compat_aggregate_init_with_ctors)
1325 bool SubobjectIsDesignatorContext,
1328 unsigned &StructuredIndex,
1329 bool TopLevelObject) {
1333 CheckComplexType(Entity, IList, DeclType, Index,
1334 StructuredList, StructuredIndex);
1336 CheckScalarType(Entity, IList, DeclType, Index,
1337 StructuredList, StructuredIndex);
1339 CheckVectorType(Entity, IList, DeclType, Index,
1340 StructuredList, StructuredIndex);
1341 }
else if (
const RecordDecl *RD = getRecordDecl(DeclType)) {
1347 "non-aggregate records should be handed in CheckSubElementType");
1348 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1349 Bases = CXXRD->bases();
1351 Bases = cast<CXXRecordDecl>(RD)->bases();
1353 CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(),
1354 SubobjectIsDesignatorContext, Index, StructuredList,
1355 StructuredIndex, TopLevelObject);
1360 CheckArrayType(Entity, IList, DeclType, Zero,
1361 SubobjectIsDesignatorContext, Index,
1362 StructuredList, StructuredIndex);
1367 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1371 CheckReferenceType(Entity, IList, DeclType, Index,
1372 StructuredList, StructuredIndex);
1375 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_init_objc_class) << DeclType;
1380 CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1387 assert(AggrDeductionCandidateParamTypes);
1388 AggrDeductionCandidateParamTypes->push_back(DeclType);
1391 SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
1402 unsigned &StructuredIndex,
1403 bool DirectlyDesignated) {
1407 return CheckReferenceType(Entity, IList, ElemType, Index,
1408 StructuredList, StructuredIndex);
1411 if (SubInitList->getNumInits() == 1 &&
1416 expr = SubInitList->getInit(0);
1419 }
else if (isa<ImplicitValueInitExpr>(
expr)) {
1423 "found implicit initialization for the wrong type");
1424 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1446 if (TmpEntity.getType()->isDependentType()) {
1451 assert(AggrDeductionCandidateParamTypes);
1452 if (!isa_and_nonnull<ConstantArrayType>(
1455 AggrDeductionCandidateParamTypes->push_back(ElemType);
1467 if (
Seq || isa<InitListExpr>(
expr)) {
1470 if (Result.isInvalid())
1473 UpdateStructuredListElement(StructuredList, StructuredIndex,
1474 Result.getAs<
Expr>());
1477 }
else if (StructuredList) {
1478 UpdateStructuredListElement(StructuredList, StructuredIndex,
1482 if (AggrDeductionCandidateParamTypes)
1483 AggrDeductionCandidateParamTypes->push_back(ElemType);
1491 return CheckScalarType(Entity, IList, ElemType, Index,
1492 StructuredList, StructuredIndex);
1506 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1535 UpdateStructuredListElement(StructuredList, StructuredIndex,
1553 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
1558 if (DirectlyDesignated && SemaRef.
getLangOpts().CPlusPlus && !hadError) {
1559 if (InOverloadResolution)
1563 diag::ext_designated_init_brace_elision)
1564 <<
expr->getSourceRange()
1579 assert(
Copy.isInvalid() &&
1580 "expected non-aggregate initialization to fail");
1592 unsigned &StructuredIndex) {
1593 assert(Index == 0 &&
"Index in explicit init list must be zero");
1603 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1608 if (!SemaRef.
getLangOpts().CPlusPlus && !VerifyOnly)
1617 for (
unsigned i = 0; i < 2; ++i) {
1619 CheckSubElementType(ElementEntity, IList, elementType, Index,
1620 StructuredList, StructuredIndex);
1628 unsigned &StructuredIndex) {
1635 ? diag::warn_cxx98_compat_empty_sizeless_initializer
1636 : diag::err_empty_sizeless_initializer)
1641 ? diag::warn_cxx98_compat_empty_scalar_initializer
1642 : diag::err_empty_scalar_initializer)
1658 SemaRef.
Diag(SubIList->getBeginLoc(), diag::ext_many_braces_around_init)
1661 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1664 }
else if (isa<DesignatedInitExpr>(
expr)) {
1667 diag::err_designator_for_scalar_or_sizeless_init)
1669 <<
expr->getSourceRange();
1679 Result = getDummyInit();
1688 Expr *ResultExpr =
nullptr;
1690 if (Result.isInvalid())
1693 ResultExpr = Result.getAs<
Expr>();
1695 if (ResultExpr !=
expr && !VerifyOnly) {
1698 IList->
setInit(Index, ResultExpr);
1701 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1703 if (AggrDeductionCandidateParamTypes)
1704 AggrDeductionCandidateParamTypes->push_back(DeclType);
1711 unsigned &StructuredIndex) {
1719 diag::err_init_reference_member_uninitialized)
1741 Result = getDummyInit();
1750 if (Result.isInvalid())
1755 if (!VerifyOnly &&
expr)
1758 UpdateStructuredListElement(StructuredList, StructuredIndex,
expr);
1760 if (AggrDeductionCandidateParamTypes)
1761 AggrDeductionCandidateParamTypes->push_back(DeclType);
1768 unsigned &StructuredIndex) {
1771 unsigned numEltsInit = 0;
1776 CheckEmptyInitializable(
1786 if (!isa<InitListExpr>(
Init) &&
Init->getType()->isVectorType()) {
1790 Result = getDummyInit();
1799 Expr *ResultExpr =
nullptr;
1800 if (Result.isInvalid())
1803 ResultExpr = Result.getAs<
Expr>();
1805 if (ResultExpr !=
Init && !VerifyOnly) {
1808 IList->
setInit(Index, ResultExpr);
1811 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1813 if (AggrDeductionCandidateParamTypes)
1814 AggrDeductionCandidateParamTypes->push_back(elementType);
1821 for (
unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1824 CheckEmptyInitializable(ElementEntity, IList->
getEndLoc());
1829 CheckSubElementType(ElementEntity, IList, elementType, Index,
1830 StructuredList, StructuredIndex);
1838 if (isBigEndian && (
T->getVectorKind() == VectorKind::Neon ||
1839 T->getVectorKind() == VectorKind::NeonPoly)) {
1851 diag::warn_neon_vector_initializer_non_portable);
1853 const char *typeCode;
1863 llvm_unreachable(
"Invalid element type!");
1867 ? diag::note_neon_vector_initializer_non_portable_q
1868 : diag::note_neon_vector_initializer_non_portable)
1869 << typeCode << typeSize;
1879 for (
unsigned i = 0; i < maxElements; ++i) {
1888 CheckSubElementType(ElementEntity, IList, elementType, Index,
1889 StructuredList, StructuredIndex);
1901 CheckSubElementType(ElementEntity, IList, VecType, Index,
1902 StructuredList, StructuredIndex);
1903 numEltsInit += numIElts;
1908 if (numEltsInit != maxElements) {
1911 diag::err_vector_incorrect_num_initializers)
1912 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1935 SemaRef.
PDiag(diag::err_access_dtor_temp)
1943 llvm::APSInt elementIndex,
1944 bool SubobjectIsDesignatorContext,
1947 unsigned &StructuredIndex) {
1959 if (Index < IList->getNumInits()) {
1972 if (StructuredList) {
1973 UpdateStructuredListElement(StructuredList, StructuredIndex,
1978 if (AggrDeductionCandidateParamTypes)
1979 AggrDeductionCandidateParamTypes->push_back(DeclType);
2000 SemaRef.
Diag(VAT->getSizeExpr()->getBeginLoc(),
2001 diag::err_variable_object_no_init)
2002 << VAT->getSizeExpr()->getSourceRange();
2011 llvm::APSInt maxElements(elementIndex.getBitWidth(),
2012 elementIndex.isUnsigned());
2013 bool maxElementsKnown =
false;
2015 maxElements = CAT->getSize();
2016 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
2017 elementIndex.setIsUnsigned(maxElements.isUnsigned());
2018 maxElementsKnown =
true;
2022 while (Index < IList->getNumInits()) {
2028 if (!SubobjectIsDesignatorContext)
2033 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
2034 DeclType,
nullptr, &elementIndex, Index,
2035 StructuredList, StructuredIndex,
true,
2041 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
2042 maxElements = maxElements.extend(elementIndex.getBitWidth());
2043 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
2044 elementIndex = elementIndex.extend(maxElements.getBitWidth());
2045 elementIndex.setIsUnsigned(maxElements.isUnsigned());
2049 if (!maxElementsKnown && elementIndex > maxElements)
2050 maxElements = elementIndex;
2057 if (maxElementsKnown && elementIndex == maxElements)
2064 CheckSubElementType(ElementEntity, IList, elementType, Index,
2065 StructuredList, StructuredIndex);
2070 if (!maxElementsKnown && elementIndex > maxElements)
2071 maxElements = elementIndex;
2076 llvm::APSInt
Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
2080 SemaRef.
Diag(IList->
getBeginLoc(), diag::ext_typecheck_zero_array_size);
2084 elementType, maxElements,
nullptr, ArraySizeModifier::Normal, 0);
2091 if ((maxElementsKnown && elementIndex < maxElements) ||
2093 CheckEmptyInitializable(
2102 bool TopLevelObject) {
2104 unsigned FlexArrayDiag;
2105 if (isa<InitListExpr>(InitExpr) &&
2106 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
2108 FlexArrayDiag = diag::ext_flexible_array_init;
2109 }
else if (!TopLevelObject) {
2111 FlexArrayDiag = diag::err_flexible_array_init;
2114 FlexArrayDiag = diag::err_flexible_array_init;
2115 }
else if (cast<VarDecl>(Entity.
getDecl())->hasLocalStorage()) {
2117 FlexArrayDiag = diag::err_flexible_array_init;
2120 FlexArrayDiag = diag::ext_flexible_array_init;
2126 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2130 return FlexArrayDiag != diag::ext_flexible_array_init;
2133void InitListChecker::CheckStructUnionTypes(
2136 bool SubobjectIsDesignatorContext,
unsigned &Index,
2137 InitListExpr *StructuredList,
unsigned &StructuredIndex,
2138 bool TopLevelObject) {
2139 const RecordDecl *RD = getRecordDecl(DeclType);
2161 if (isa<CXXRecordDecl>(RD) &&
2162 cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
2163 if (!StructuredList)
2166 Field != FieldEnd; ++Field) {
2167 if (
Field->hasInClassInitializer()) {
2178 Field != FieldEnd; ++Field) {
2179 if (!
Field->isUnnamedBitField()) {
2180 CheckEmptyInitializable(
2191 bool InitializedSomething =
false;
2194 for (
auto I = Bases.begin(), E = Bases.end(); I != E; ++I) {
2200 if (
Init && isa<DesignatedInitExpr>(
Init))
2217 if (AggrDeductionCandidateParamTypes &&
Base.isPackExpansion()) {
2218 AggrDeductionCandidateParamTypes->push_back(
2223 if (Index < IList->getNumInits())
2235 CheckSubElementType(BaseEntity, IList,
Base.getType(), Index,
2236 StructuredList, StructuredIndex);
2237 InitializedSomething =
true;
2239 CheckEmptyInitializable(BaseEntity, InitLoc);
2254 size_t NumRecordDecls = llvm::count_if(RD->
decls(), [&](
const Decl *D) {
2255 return isa<FieldDecl>(D) || isa<RecordDecl>(D);
2257 bool HasDesignatedInit =
false;
2261 while (Index < IList->getNumInits()) {
2269 if (!SubobjectIsDesignatorContext)
2272 HasDesignatedInit =
true;
2276 bool DesignatedInitFailed = CheckDesignatedInitializer(
2277 Entity, IList, DIE, 0, DeclType, &Field,
nullptr, Index,
2278 StructuredList, StructuredIndex,
true, TopLevelObject);
2279 if (DesignatedInitFailed)
2286 InitializedFields.insert(F);
2287 if (!DesignatedInitFailed) {
2296 InitializedSomething =
true;
2313 if (NumRecordDecls == 1)
2315 if (
const auto *IL = dyn_cast<IntegerLiteral>(I))
2316 return IL->getValue().isZero();
2324 SemaRef.
Diag(InitLoc, diag::err_non_designated_init_used);
2329 if (Field == FieldEnd) {
2335 if (InitializedSomething && RD->
isUnion())
2339 if (
Field->getType()->isIncompleteArrayType())
2342 if (
Field->isUnnamedBitField()) {
2351 InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
2372 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2373 StructuredList, StructuredIndex);
2374 InitializedSomething =
true;
2375 InitializedFields.insert(*Field);
2377 if (RD->
isUnion() && StructuredList) {
2388 bool IsCDesignatedInitializer =
2389 HasDesignatedInit && !SemaRef.
getLangOpts().CPlusPlus;
2390 if (!VerifyOnly && InitializedSomething && !RD->
isUnion() &&
2392 !IsCDesignatedInitializer) {
2399 if (HasDesignatedInit && InitializedFields.count(*it))
2402 if (!it->isUnnamedBitField() && !it->hasInClassInitializer() &&
2403 !it->getType()->isIncompleteArrayType()) {
2404 auto Diag = HasDesignatedInit
2405 ? diag::warn_missing_designated_field_initializers
2406 : diag::warn_missing_field_initializers;
2415 if (!StructuredList && Field != FieldEnd && !RD->
isUnion() &&
2416 !
Field->getType()->isIncompleteArrayType()) {
2417 for (;
Field != FieldEnd && !hadError; ++
Field) {
2418 if (!
Field->isUnnamedBitField() && !
Field->hasInClassInitializer())
2419 CheckEmptyInitializable(
2440 if (Field == FieldEnd || !
Field->getType()->isIncompleteArrayType() ||
2444 if (CheckFlexibleArrayInit(Entity, IList->
getInit(Index), *Field,
2454 if (isa<InitListExpr>(IList->
getInit(Index)) ||
2455 AggrDeductionCandidateParamTypes)
2456 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2457 StructuredList, StructuredIndex);
2459 CheckImplicitInitList(MemberEntity, IList,
Field->getType(), Index,
2460 StructuredList, StructuredIndex);
2462 if (RD->
isUnion() && StructuredList) {
2481 PE = IndirectField->
chain_end(); PI != PE; ++PI) {
2489 assert(isa<FieldDecl>(*PI));
2490 Replacements.back().setFieldDecl(cast<FieldDecl>(*PI));
2497 &Replacements[0] + Replacements.size());
2504 for (
unsigned I = 0; I < NumIndexExprs; ++I)
2518 explicit FieldInitializerValidatorCCC(
const RecordDecl *RD)
2526 std::unique_ptr<CorrectionCandidateCallback>
clone()
override {
2527 return std::make_unique<FieldInitializerValidatorCCC>(*
this);
2580 llvm::APSInt *NextElementIndex,
2583 unsigned &StructuredIndex,
2584 bool FinishSubobjectInit,
2585 bool TopLevelObject) {
2586 if (DesigIdx == DIE->
size()) {
2593 assert(isa<InitListExpr>(
Init) &&
2594 "designator result in direct non-list initialization?");
2599 if (StructuredList) {
2603 UpdateStructuredListElement(StructuredList, StructuredIndex,
2607 if (AggrDeductionCandidateParamTypes)
2608 AggrDeductionCandidateParamTypes->push_back(CurrentObjectType);
2613 bool prevHadError = hadError;
2618 unsigned OldIndex = Index;
2621 CheckSubElementType(Entity, IList, CurrentObjectType, Index, StructuredList,
2622 StructuredIndex,
true);
2628 IList->
setInit(OldIndex, DIE);
2630 return hadError && !prevHadError;
2634 bool IsFirstDesignator = (DesigIdx == 0);
2635 if (IsFirstDesignator ? FullyStructuredList : StructuredList) {
2638 if (IsFirstDesignator)
2639 StructuredList = FullyStructuredList;
2641 Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2642 StructuredList->getInit(StructuredIndex) :
nullptr;
2643 if (!ExistingInit && StructuredList->hasArrayFiller())
2644 ExistingInit = StructuredList->getArrayFiller();
2647 StructuredList = getStructuredSubobjectInit(
2648 IList, Index, CurrentObjectType, StructuredList, StructuredIndex,
2650 else if (
InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2651 StructuredList = Result;
2664 diagnoseInitOverride(ExistingInit,
2671 dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2672 StructuredList = E->getUpdater();
2677 StructuredList->updateInit(SemaRef.
Context, StructuredIndex, DIUE);
2686 StructuredList =
nullptr;
2702 RecordDecl *RD = getRecordDecl(CurrentObjectType);
2708 SemaRef.
Diag(
Loc, diag::err_field_designator_non_aggr)
2709 << SemaRef.
getLangOpts().CPlusPlus << CurrentObjectType;
2718 if (
auto *FD = dyn_cast_if_present<FieldDecl>(VD)) {
2720 }
else if (
auto *IFD = dyn_cast_if_present<IndirectFieldDecl>(VD)) {
2726 KnownField = cast<FieldDecl>(*IFD->chain_begin());
2745 SemaRef.
Diag(Lookup.front()->getLocation(),
2746 diag::note_field_designator_found);
2753 FieldInitializerValidatorCCC CCC(RD);
2760 SemaRef.
PDiag(diag::err_field_designator_unknown_suggest)
2761 << FieldName << CurrentObjectType);
2762 KnownField = Corrected.getCorrectionDeclAs<
FieldDecl>();
2773 SemaRef.
Diag(
Loc, diag::err_field_designator_unknown)
2781 unsigned NumBases = 0;
2782 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2783 NumBases = CXXRD->getNumBases();
2785 unsigned FieldIndex = NumBases;
2787 for (
auto *FI : RD->
fields()) {
2788 if (FI->isUnnamedBitField())
2804 if (StructuredList) {
2805 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2807 assert(StructuredList->getNumInits() == 1
2808 &&
"A union should never have more than one initializer!");
2810 Expr *ExistingInit = StructuredList->getInit(0);
2813 diagnoseInitOverride(
2821 StructuredList->resizeInits(SemaRef.
Context, 0);
2822 StructuredList->setInitializedFieldInUnion(
nullptr);
2825 StructuredList->setInitializedFieldInUnion(*Field);
2832 InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
2855 if (IsFirstDesignator && !VerifyOnly && SemaRef.
getLangOpts().CPlusPlus &&
2858 (*NextField)->getFieldIndex() >
Field->getFieldIndex() + 1)) {
2862 if (FI->isUnnamedBitField())
2873 diag::ext_designated_init_reordered)
2876 unsigned OldIndex = StructuredIndex - 1;
2877 if (StructuredList && OldIndex <= StructuredList->getNumInits()) {
2878 if (
Expr *PrevInit = StructuredList->getInit(OldIndex)) {
2879 SemaRef.
Diag(PrevInit->getBeginLoc(),
2880 diag::note_previous_field_init)
2894 if (StructuredList && FieldIndex >= StructuredList->getNumInits())
2895 StructuredList->resizeInits(SemaRef.
Context, FieldIndex + 1);
2898 if (
Field->getType()->isIncompleteArrayType()) {
2900 if ((DesigIdx + 1) != DIE->
size()) {
2907 diag::err_designator_into_flexible_array_member)
2909 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2915 if (!hadError && !isa<InitListExpr>(DIE->
getInit()) &&
2916 !isa<StringLiteral>(DIE->
getInit())) {
2920 diag::err_flexible_array_init_needs_braces)
2922 SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
2929 if (!
Invalid && CheckFlexibleArrayInit(Entity, DIE->
getInit(), *Field,
2939 bool prevHadError = hadError;
2940 unsigned newStructuredIndex = FieldIndex;
2941 unsigned OldIndex = Index;
2946 CheckSubElementType(MemberEntity, IList,
Field->getType(), Index,
2947 StructuredList, newStructuredIndex);
2949 IList->
setInit(OldIndex, DIE);
2950 if (hadError && !prevHadError) {
2955 StructuredIndex = FieldIndex;
2961 unsigned newStructuredIndex = FieldIndex;
2965 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2966 FieldType,
nullptr,
nullptr, Index,
2967 StructuredList, newStructuredIndex,
2968 FinishSubobjectInit,
false))
2979 if (IsFirstDesignator) {
2986 StructuredIndex = FieldIndex;
2990 if (!FinishSubobjectInit)
2998 bool prevHadError = hadError;
3003 CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,
3004 false, Index, StructuredList, FieldIndex);
3005 return hadError && !prevHadError;
3027 << CurrentObjectType;
3032 Expr *IndexExpr =
nullptr;
3033 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
3037 DesignatedEndIndex = DesignatedStartIndex;
3041 DesignatedStartIndex =
3043 DesignatedEndIndex =
3052 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
3057 if (isa<ConstantArrayType>(AT)) {
3058 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(),
false);
3059 DesignatedStartIndex
3060 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
3061 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
3063 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
3064 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
3065 if (DesignatedEndIndex >= MaxElements) {
3068 diag::err_array_designator_too_large)
3075 unsigned DesignatedIndexBitWidth =
3077 DesignatedStartIndex =
3078 DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
3079 DesignatedEndIndex =
3080 DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
3081 DesignatedStartIndex.setIsUnsigned(
true);
3082 DesignatedEndIndex.setIsUnsigned(
true);
3085 bool IsStringLiteralInitUpdate =
3086 StructuredList && StructuredList->isStringLiteralInit();
3087 if (IsStringLiteralInitUpdate && VerifyOnly) {
3090 StructuredList =
nullptr;
3091 }
else if (IsStringLiteralInitUpdate) {
3104 unsigned PromotedCharTyWidth = Context.
getTypeSize(PromotedCharTy);
3109 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
3110 StrLen = cast<ConstantArrayType>(AT)->getZExtSize();
3111 StructuredList->resizeInits(Context, StrLen);
3115 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
3116 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
3118 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
3119 if (CharTy != PromotedCharTy)
3123 StructuredList->updateInit(Context, i,
Init);
3132 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
3133 StrLen = cast<ConstantArrayType>(AT)->getZExtSize();
3134 StructuredList->resizeInits(Context, StrLen);
3138 for (
unsigned i = 0, e = StrLen; i != e; ++i) {
3139 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
3141 Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
3142 if (CharTy != PromotedCharTy)
3146 StructuredList->updateInit(Context, i,
Init);
3153 if (StructuredList &&
3154 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
3155 StructuredList->resizeInits(SemaRef.
Context,
3156 DesignatedEndIndex.getZExtValue() + 1);
3162 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
3163 unsigned OldIndex = Index;
3168 while (DesignatedStartIndex <= DesignatedEndIndex) {
3174 if (CheckDesignatedInitializer(
3175 ElementEntity, IList, DIE, DesigIdx + 1, ElementType,
nullptr,
3176 nullptr, Index, StructuredList, ElementIndex,
3177 FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),
3182 ++DesignatedStartIndex;
3183 ElementIndex = DesignatedStartIndex.getZExtValue();
3188 if (IsFirstDesignator) {
3189 if (NextElementIndex)
3190 *NextElementIndex = DesignatedStartIndex;
3191 StructuredIndex = ElementIndex;
3195 if (!FinishSubobjectInit)
3199 bool prevHadError = hadError;
3200 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
3202 StructuredList, ElementIndex);
3203 return hadError && !prevHadError;
3209InitListChecker::getStructuredSubobjectInit(
InitListExpr *IList,
unsigned Index,
3212 unsigned StructuredIndex,
3214 bool IsFullyOverwritten) {
3215 if (!StructuredList)
3218 Expr *ExistingInit =
nullptr;
3219 if (StructuredIndex < StructuredList->getNumInits())
3220 ExistingInit = StructuredList->
getInit(StructuredIndex);
3222 if (
InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
3231 if (!IsFullyOverwritten)
3254 diagnoseInitOverride(ExistingInit, InitRange);
3257 unsigned ExpectedNumInits = 0;
3258 if (Index < IList->getNumInits()) {
3259 if (
auto *
Init = dyn_cast_or_null<InitListExpr>(IList->
getInit(Index)))
3260 ExpectedNumInits =
Init->getNumInits();
3266 createInitListExpr(CurrentObjectType, InitRange, ExpectedNumInits);
3275InitListChecker::createInitListExpr(
QualType CurrentObjectType,
3277 unsigned ExpectedNumInits) {
3281 QualType ResultType = CurrentObjectType;
3284 Result->setType(ResultType);
3287 unsigned NumElements = 0;
3292 NumElements = CAType->getZExtSize();
3295 if (NumElements > ExpectedNumInits)
3299 NumElements = VType->getNumElements();
3301 NumElements = numStructUnionElements(CurrentObjectType);
3306 Result->reserveInits(SemaRef.
Context, NumElements);
3313void InitListChecker::UpdateStructuredListElement(
InitListExpr *StructuredList,
3314 unsigned &StructuredIndex,
3317 if (!StructuredList)
3321 StructuredIndex,
expr)) {
3327 diagnoseInitOverride(PrevInit,
expr->getSourceRange());
3338 InitListChecker Check(*
this, Entity, From,
Type,
true,
3341 return !Check.HadError();
3362 return S.
Diag(
Loc, diag::err_array_designator_negative)
3365 Value.setIsUnsigned(
true);
3384 Designators.push_back(ASTDesignator::CreateFieldDesignator(
3388 llvm::APSInt IndexValue;
3389 if (!Index->isTypeDependent() && !Index->isValueDependent())
3394 Designators.push_back(ASTDesignator::CreateArrayDesignator(
3396 InitExpressions.push_back(Index);
3401 llvm::APSInt StartValue;
3402 llvm::APSInt EndValue;
3407 if (!StartDependent)
3413 if (!StartIndex || !EndIndex)
3417 if (StartDependent || EndDependent) {
3419 }
else if (StartValue.getBitWidth() > EndValue.getBitWidth())
3420 EndValue = EndValue.extend(StartValue.getBitWidth());
3421 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
3422 StartValue = StartValue.extend(EndValue.getBitWidth());
3424 if (!StartDependent && !EndDependent && EndValue < StartValue) {
3430 Designators.push_back(ASTDesignator::CreateArrayRangeDesignator(
3433 InitExpressions.push_back(StartIndex);
3434 InitExpressions.push_back(EndIndex);
3444 EqualOrColonLoc, GNUSyntax,
3452InitializedEntity::InitializedEntity(
ASTContext &Context,
unsigned Index,
3457 Kind = EK_ArrayElement;
3460 Kind = EK_VectorElement;
3464 assert(CT &&
"Unexpected type");
3465 Kind = EK_ComplexElement;
3473 bool IsInheritedVirtualBase,
3478 Result.Base = {
Base, IsInheritedVirtualBase};
3496 return Variable.VariableOrMember->getDeclName();
3518 llvm_unreachable(
"Invalid EntityKind!");
3552 llvm_unreachable(
"Invalid EntityKind!");
3587unsigned InitializedEntity::dumpImpl(raw_ostream &OS)
const {
3590 for (
unsigned I = 0; I != Depth; ++I)
3607 case EK_New: OS <<
"New";
break;
3611 case EK_Base: OS <<
"Base";
break;
3618 OS <<
"Block (lambda)";
3621 OS <<
"LambdaCapture ";
3628 D->printQualifiedName(OS);
3631 OS <<
" '" <<
getType() <<
"'\n";
3637 dumpImpl(llvm::errs());
3692 for (
const Step &S : llvm::reverse(Steps)) {
3752 llvm_unreachable(
"Invalid EntityKind!");
3760InitializationSequence
3763 bool HadMultipleCandidates) {
3767 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3769 S.Function.FoundDecl = Found;
3788 bool BindingTemporary) {
3813 bool HadMultipleCandidates) {
3817 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3819 S.Function.FoundDecl = FoundDecl;
3858 bool TopLevelOfInitList) {
3876 bool HadMultipleCandidates,
bool FromInitList,
bool AsInitList) {
3882 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3883 S.Function.Function = Constructor;
3884 S.Function.FoundDecl = FoundDecl;
3927 Steps.insert(Steps.begin(), S);
3988 "Can only rewrap trivial init lists.");
3992 Steps.insert(Steps.begin(), S);
3996 S.WrappingSyntacticList = Syntactic;
4003 this->Failure = Failure;
4004 this->FailedOverloadResult =
Result;
4025 if (!
Init.empty()) {
4045 "consuming an object of unretainable type?");
4066 bool TreatUnavailableAsInvalid);
4077 bool TreatUnavailableAsInvalid) {
4091 List->getNumInits()),
4096 List->getExprLoc(), List->getBeginLoc(), List->getEndLoc());
4098 TreatUnavailableAsInvalid);
4125 bool CopyInitializing,
bool AllowExplicit,
bool OnlyListConstructors,
4126 bool IsListInit,
bool RequireActualConstructor,
4127 bool SecondStepOfCopyInit =
false) {
4133 if (!Info.Constructor || Info.Constructor->isInvalidDecl())
4150 bool SuppressUserConversions =
4151 SecondStepOfCopyInit ||
4152 (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
4155 if (Info.ConstructorTmpl)
4157 Info.ConstructorTmpl, Info.FoundDecl,
4158 nullptr, Args, CandidateSet, SuppressUserConversions,
4159 false, AllowExplicit);
4168 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
4172 CandidateSet, SuppressUserConversions,
4173 false, AllowExplicit,
4189 if (S.
getLangOpts().CPlusPlus17 && Args.size() == 1 &&
4190 !RequireActualConstructor && !SecondStepOfCopyInit) {
4192 auto *SourceRD =
Initializer->getType()->getAsCXXRecordDecl();
4194 const auto &Conversions = SourceRD->getVisibleConversionFunctions();
4195 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4205 Conv = cast<CXXConversionDecl>(D);
4209 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4210 CandidateSet, AllowExplicit, AllowExplicit,
4214 DestType, CandidateSet, AllowExplicit,
4241 bool IsListInit =
false,
4242 bool IsInitListCopy =
false) {
4243 assert(((!IsListInit && !IsInitListCopy) ||
4244 (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
4245 "IsListInit/IsInitListCopy must come with a single initializer list "
4248 (IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) :
nullptr;
4258 bool RequireActualConstructor =
4273 if (S.
getLangOpts().CPlusPlus17 && !RequireActualConstructor &&
4274 UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isPRValue() &&
4284 assert(DestRecordType &&
"Constructor initialization requires record type");
4286 = cast<CXXRecordDecl>(DestRecordType->
getDecl());
4294 bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
4304 bool AsInitializerList =
false;
4316 AsInitializerList =
true;
4322 S, Kind.getLocation(), Args, CandidateSet, DestType, Ctors, Best,
4323 CopyInitialization, AllowExplicit,
4324 true, IsListInit, RequireActualConstructor);
4333 AsInitializerList =
false;
4335 S, Kind.getLocation(), UnwrappedArgs, CandidateSet, DestType, Ctors,
4336 Best, CopyInitialization, AllowExplicit,
4337 false, IsListInit, RequireActualConstructor);
4349 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4353 if (
auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
4355 QualType ConvType = CD->getConversionType();
4357 "should not have selected this conversion function");
4359 HadMultipleCandidates);
4390 if (IsListInit && !Kind.AllowExplicit() && CtorDecl->
isExplicit()) {
4410 Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,
4411 IsListInit | IsInitListCopy, AsInitializerList);
4424 bool HadMultipleCandidates =
false;
4427 UnqualifiedTargetType,
4429 &HadMultipleCandidates)) {
4431 HadMultipleCandidates);
4432 SourceType = Fn->getType();
4451 bool TopLevelOfInitList);
4465 bool TreatUnavailableAsInvalid) {
4505 T1Quals, cv2T2, T2, T2Quals, Sequence,
4536 TreatUnavailableAsInvalid);
4568 bool TreatUnavailableAsInvalid) {
4580 TreatUnavailableAsInvalid);
4618 !IsDesignatedInit) {
4623 Expr *InitListAsExpr = InitList;
4633 if (!isa<VariableArrayType>(DestAT) &&
4643 TreatUnavailableAsInvalid);
4676 TreatUnavailableAsInvalid))
4680 Expr *InitListAsExpr = InitList;
4682 DestType, Sequence,
true);
4700 ET && ET->getDecl()->isFixed() &&
4749 if (
Init->getType()->isRecordType() ||
4760 TreatUnavailableAsInvalid);
4767 InitListChecker CheckInitList(S, Entity, InitList,
4768 DestType,
true, TreatUnavailableAsInvalid);
4769 if (CheckInitList.HadError()) {
4791 "Must have incompatible references when binding via conversion");
4802 bool AllowExplicitCtors =
false;
4803 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
4814 if (!Info.Constructor)
4817 if (!Info.Constructor->isInvalidDecl() &&
4818 Info.Constructor->isConvertingConstructor(
true)) {
4819 if (Info.ConstructorTmpl)
4821 Info.ConstructorTmpl, Info.FoundDecl,
4824 false, AllowExplicitCtors);
4827 Info.Constructor, Info.FoundDecl,
Initializer, CandidateSet,
4829 false, AllowExplicitCtors);
4844 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4847 if (isa<UsingShadowDecl>(D))
4848 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4855 Conv = cast<CXXConversionDecl>(D);
4863 if ((AllowRValues ||
4867 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
4869 false, AllowExplicitConvs);
4872 Conv, I.getPair(), ActingDC,
Initializer, DestType, CandidateSet,
4873 false, AllowExplicitConvs);
4895 if (isa<CXXConversionDecl>(
Function))
4908 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
4910 HadMultipleCandidates);
4920 assert(!isa<CXXConstructorDecl>(
Function) &&
4921 "should not have conversion after constructor");
4925 ICS.
Standard = Best->FinalConversion;
4946 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
4948 else if (RefConv & Sema::ReferenceConversions::ObjC)
4950 else if (RefConv & Sema::ReferenceConversions::Function)
4952 else if (RefConv & Sema::ReferenceConversions::Qualification) {
4969 bool TopLevelOfInitList) {
4987 T1Quals, cv2T2, T2, T2Quals, Sequence,
4988 TopLevelOfInitList);
5012 bool TopLevelOfInitList) {
5036 if (isLValueRef || T1Function) {
5039 (Kind.isCStyleOrFunctionalCast() &&
5043 if (RefConv & (Sema::ReferenceConversions::DerivedToBase |
5044 Sema::ReferenceConversions::ObjC)) {
5047 if (RefConv & (Sema::ReferenceConversions::Qualification))
5051 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
5055 }
else if (RefConv & Sema::ReferenceConversions::Qualification) {
5059 }
else if (RefConv & Sema::ReferenceConversions::Function) {
5079 (isLValueRef || InitCategory.
isRValue())) {
5084 isLValueRef, Sequence);
5118 switch (RefRelationship) {
5130 llvm_unreachable(
"unexpected kind of compatible initializer");
5154 (Kind.isCStyleOrFunctionalCast() &&
5183 auto T1QualsIgnoreAS = T1Quals;
5184 auto T2QualsIgnoreAS = T2Quals;
5187 T2QualsIgnoreAS.removeAddressSpace();
5190 if (T1QualsIgnoreAS != T2QualsIgnoreAS)
5200 cv1T4 = cv1T4WithAS;
5205 if (RefConv & Sema::ReferenceConversions::DerivedToBase)
5207 else if (RefConv & Sema::ReferenceConversions::ObjC)
5209 else if (RefConv & Sema::ReferenceConversions::Qualification) {
5226 isLValueRef, Sequence);
5266 Sema::AllowedExplicit::None,
5268 Kind.isCStyleOrFunctionalCast(),
5287 TopLevelOfInitList);
5296 ((T1CVRQuals | T2CVRQuals) != T1CVRQuals ||
5341 assert((!InitList || InitList->
getNumInits() == 0) &&
5342 "Shouldn't use value-init for non-empty init lists");
5353 if (
CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
5354 bool NeedZeroInitialization =
true;
5369 NeedZeroInitialization =
false;
5377 if (NeedZeroInitialization)
5391 ClassDecl->hasUninitializedReferenceMember()) {
5399 Expr *InitListAsExpr = InitList;
5401 bool InitListSyntax = InitList;
5406 S, Entity, Kind, Args,
T, Entity.
getType(), Sequence, InitListSyntax);
5456 unsigned EntityIndexToProcess = 0;
5459 Expr *ArrayFiller =
nullptr;
5460 FieldDecl *InitializedFieldInUnion =
nullptr;
5464 Expr *Arg,
Expr **InitExpr =
nullptr) {
5466 S, SubEntity, SubKind, Arg ?
MultiExprArg(Arg) : std::nullopt);
5480 ER = IS.
Perform(S, SubEntity, SubKind,
5483 *InitExpr = ER.
get();
5485 InitExprs.push_back(ER.
get());
5493 uint64_t ArrayLength;
5501 ArrayLength = CAT->getZExtSize();
5502 ResultType = Entity.
getType();
5509 const Expr *SE = VAT->getSizeExpr();
5514 assert(isa<IncompleteArrayType>(Entity.
getType()));
5515 ArrayLength = Args.size();
5517 EntityIndexToProcess = ArrayLength;
5521 for (
Expr *E : Args) {
5526 if (!HandleInitializedEntity(SubEntity, SubKind, E))
5534 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
true);
5535 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr, &ArrayFiller))
5539 if (ResultType.
isNull()) {
5546 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
5560 if (EntityIndexToProcess < Args.size()) {
5566 Expr *E = Args[EntityIndexToProcess];
5569 if (!HandleInitializedEntity(SubEntity, SubKind, E))
5577 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
5579 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr))
5582 EntityIndexToProcess++;
5595 if (EntityIndexToProcess < Args.size()) {
5597 Expr *E = Args[EntityIndexToProcess];
5615 if (!HandleInitializedEntity(SubEntity, SubKind, E))
5623 InitializedFieldInUnion = FD;
5624 EntityIndexToProcess = 1;
5636 Kind.getParenOrBraceRange().getEnd(), FD);
5640 InitExprs.push_back(DIE.
get());
5650 S.
Diag(SR.
getEnd(), diag::err_init_reference_member_uninitialized)
5657 Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
true);
5658 if (!HandleInitializedEntity(SubEntity, SubKind,
nullptr))
5662 EntityIndexToProcess++;
5664 ResultType = Entity.
getType();
5669 if (EntityIndexToProcess < Args.size()) {
5674 SourceRange ExcessInitSR(Args[EntityIndexToProcess]->getBeginLoc(),
5675 Args.back()->getEndLoc());
5676 S.
Diag(Kind.getLocation(), diag::err_excess_initializers)
5677 << InitKind << ExcessInitSR;
5691 CPLIE->setArrayFiller(ArrayFiller);
5692 if (InitializedFieldInUnion)
5693 CPLIE->setInitializedFieldInUnion(InitializedFieldInUnion);
5695 S.
Diag(Kind.getLocation(),
5696 diag::warn_cxx17_compat_aggregate_init_paren_list)
5697 << Kind.getLocation() << SR << ResultType;
5709 bool TopLevelOfInitList) {
5710 assert(!DestType->
isReferenceType() &&
"References are handled elsewhere");
5713 "Must have a class type to perform a user-defined conversion");
5723 bool AllowExplicit = Kind.AllowExplicit();
5729 = cast<CXXRecordDecl>(DestRecordType->getDecl());
5735 if (!Info.Constructor)
5738 if (!Info.Constructor->isInvalidDecl() &&
5739 Info.Constructor->isConvertingConstructor(
true)) {
5740 if (Info.ConstructorTmpl)
5742 Info.ConstructorTmpl, Info.FoundDecl,
5745 false, AllowExplicit);
5750 false, AllowExplicit);
5766 = cast<CXXRecordDecl>(SourceRecordType->getDecl());
5768 const auto &Conversions =
5770 for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
5773 if (isa<UsingShadowDecl>(D))
5774 D = cast<UsingShadowDecl>(D)->getTargetDecl();
5781 Conv = cast<CXXConversionDecl>(D);
5785 ConvTemplate, I.getPair(), ActingDC,
Initializer, DestType,
5786 CandidateSet, AllowExplicit, AllowExplicit);
5789 DestType, CandidateSet, AllowExplicit,
5815 bool HadMultipleCandidates = (CandidateSet.
size() > 1);
5817 if (isa<CXXConstructorDecl>(
Function)) {
5823 HadMultipleCandidates);
5852 HadMultipleCandidates);
5865 Function->getReturnType()->isReferenceType() ||
5875 if (Best->FinalConversion.First || Best->FinalConversion.Second ||
5876 Best->FinalConversion.Third) {
5879 ICS.
Standard = Best->FinalConversion;
5897 isa<CXXBoolLiteralExpr>(
Init) &&
5898 !cast<CXXBoolLiteralExpr>(
Init)->getValue() &&
5907 bool isAddressOf,
bool &isWeakAccess) {
5913 if (op->getOpcode() == UO_AddrOf)
5918 }
else if (
CastExpr *ce = dyn_cast<CastExpr>(e)) {
5919 switch (ce->getCastKind()) {
5922 case CK_LValueBitCast:
5926 case CK_ArrayToPointerDecay:
5929 case CK_NullToPointer:
5937 }
else if (isa<DeclRefExpr>(e)) {
5941 isWeakAccess =
true;
5945 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
5959 }
else if (isa<ArraySubscriptExpr>(e)) {
5975 bool isWeakAccess =
false;
5979 if (S.
getLangOpts().ObjCAutoRefCount && isWeakAccess)
6011 bool ArrayDecay =
false;
6016 ArgPointee = ArgArrayType->getElementType();
6028 bool ShouldCopy =
true;
6099 "cl_intel_device_side_avc_motion_estimation", S.
getLangOpts()) &&
6101 if (DestType->isOCLIntelSubgroupAVCMcePayloadType() ||
6102 DestType->isOCLIntelSubgroupAVCMceResultType())
6116 MultiExprArg Args,
bool TopLevelOfInitList,
bool TreatUnavailableAsInvalid)
6120 TreatUnavailableAsInvalid);
6126 auto *DRE = dyn_cast<DeclRefExpr>(E);
6127 if (!DRE || !isa<FunctionDecl>(DRE->getDecl()))
6131 cast<FunctionDecl>(DRE->getDecl()));
6148 return isa<DecompositionDecl>(Entity.
getDecl());
6174 bool TopLevelOfInitList,
6175 bool TreatUnavailableAsInvalid) {
6182 for (
unsigned I = 0, E = Args.size(); I != E; ++I)
6183 if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
6190 Args[I] = result.
get();
6212 if (Args.size() == 1) {
6230 TreatUnavailableAsInvalid);
6242 if (Args.size() != 1)
6248 else if (isa<InitListExpr>(Args[0]))
6252 TopLevelOfInitList);
6278 if (
Initializer && isa<VariableArrayType>(DestAT)) {
6310 if (
Initializer && isa<ConstantArrayType>(DestAT) &&
6328 Expr *OVEAsExpr = &OVE;
6330 TreatUnavailableAsInvalid);
6340 isa<CompoundLiteralExpr>(
Initializer->IgnoreParens()) &&
6358 *
this, TreatUnavailableAsInvalid);
6360 }
else if (S.
getLangOpts().CPlusPlus20 && !TopLevelOfInitList &&
6376 bool allowObjCWritebackConversion = S.
getLangOpts().ObjCAutoRefCount &&
6385 assert(
Initializer &&
"Initializer must be non-null");
6387 if (allowObjCWritebackConversion &&
6413 SourceType, DestType))))) {
6420 if (
const auto *RD =
6425 S.
getLangOpts().CPlusPlus20 && RD && RD->hasDefinition() &&
6426 RD->isAggregate() &&
Failed() &&
6439 S, Kind.getLocation(), Best);
6457 assert(
Initializer &&
"Initializer must be non-null");
6459 TopLevelOfInitList);
6464 assert(Args.size() >= 1 &&
"Zero-argument case handled above");
6474 for (
auto *Arg : Args) {
6475 if (Arg->getType()->isExtVectorType()) {
6478 for (
unsigned Idx = 0; Idx < Elm; ++Idx) {
6484 VTy->getElementType(), Arg->
getValueKind(), Arg->getObjectKind(),
6488 InitArgs.emplace_back(Arg);
6498 if (Args.size() > 1) {
6501 }
else if (isa<InitListExpr>(Args[0])) {
6509 assert(
Initializer &&
"Initializer must be non-null");
6512 bool NeedAtomicConversion =
false;
6516 Atomic->getValueType())) {
6517 DestType =
Atomic->getValueType();
6518 NeedAtomicConversion =
true;
6523 TopLevelOfInitList);
6525 if (!
Failed() && NeedAtomicConversion)
6552 Sema::AllowedExplicit::None,
6554 Kind.isCStyleOrFunctionalCast(),
6555 allowObjCWritebackConversion);
6563 bool ShouldCopy =
true;
6579 }
else if (ICS.
isBad()) {
6587 else if (
Initializer->getType()->isFunctionType() &&
6600 for (
auto &S : Steps)
6658 llvm_unreachable(
"Invalid EntityKind!");
6692 llvm_unreachable(
"missed an InitializedEntity kind?");
6726 llvm_unreachable(
"missed an InitializedEntity kind?");
6765 llvm_unreachable(
"missed an InitializedEntity kind?");
6792 bool IsExtraneousCopy) {
6817 S,
Loc, CurInitExpr, CandidateSet,
T, Ctors, Best,
6829 ? diag::ext_rvalue_to_reference_temp_copy_no_viable
6830 : diag::err_temp_copy_no_viable)
6848 S.
Diag(
Loc, diag::err_temp_copy_deleted)
6855 bool HadMultipleCandidates = CandidateSet.
size() > 1;
6864 if (IsExtraneousCopy) {
6875 for (
unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
6878 diag::err_call_incomplete_argument))
6919 Best->Function->getParamDecl(0)->getType().getNonReferenceType(),
6924 Loc,
T, Best->FoundDecl, Constructor, Elidable, ConstructorArgs,
6925 HadMultipleCandidates,
6941 Expr *CurInitExpr) {
6960 S,
Loc, CurInitExpr, CandidateSet, CurInitExpr->
getType(), Ctors, Best,
6973 Best->FoundDecl, Entity,
Diag);
6994void InitializationSequence::PrintInitLocationNote(
Sema &S,
7009 diag::note_method_return_type_change)
7027 switch (Kind.getKind()) {
7033 return NumArgs != 1;
7045 bool &ConstructorInitRequiresZeroInit,
7046 bool IsListInitialization,
7047 bool IsStdInitListInitialization,
7050 unsigned NumArgs = Args.size();
7058 ? Kind.getEqualLoc()
7059 : Kind.getLocation();
7065 assert(Constructor->getParent() &&
"No parent class for constructor.");
7066 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
7067 Constructor->isTrivial() && !Constructor->isUsed(
false)) {
7082 bool AllowExplicitConv =
7083 Kind.AllowExplicit() && !Kind.isCopyInit() && Args.size() == 1 &&
7088 if (NumArgs == 1 && !Kind.isExplicitCast())
7090 Entity.
getType(), Args.front()->getType(), Kind.getLocation());
7095 ConstructorArgs, AllowExplicitConv,
7096 IsListInitialization))
7110 : Kind.getParenOrBraceRange();
7113 if (
auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(
7123 ConstructorArgs, ParenOrBraceRange, HadMultipleCandidates,
7124 IsListInitialization, IsStdInitListInitialization,
7125 ConstructorInitRequiresZeroInit),
7141 if (IsListInitialization)
7142 ParenOrBraceRange =
SourceRange(LBraceLoc, RBraceLoc);
7144 ParenOrBraceRange = Kind.getParenOrBraceRange();
7153 HadMultipleCandidates,
7154 IsListInitialization,
7155 IsStdInitListInitialization,
7156 ConstructorInitRequiresZeroInit,
7164 HadMultipleCandidates,
7165 IsListInitialization,
7166 IsStdInitListInitialization,
7167 ConstructorInitRequiresZeroInit,
7215using LifetimeResult =
7216 llvm::PointerIntPair<const InitializedEntity *, 3, LifetimeKind>;
7229 return {Entity, LK_Extended};
7249 : LK_MemInitializer};
7254 return {Entity, LK_Extended};
7261 return {
nullptr, LK_FullExpression};
7265 return {
nullptr, LK_FullExpression};
7271 return {
nullptr, LK_Return};
7276 return {
nullptr, LK_StmtExprResult};
7282 return {
nullptr, LK_New};
7290 return {
nullptr, LK_FullExpression};
7300 return {InitField, LK_MemInitializer};
7307 return {InitField, LK_MemInitializer};
7314 return {
nullptr, LK_FullExpression};
7318 return {
nullptr, LK_FullExpression};
7325 return {
nullptr, LK_FullExpression};
7328 llvm_unreachable(
"unknown entity kind");
7334 RK_ReferenceBinding,
7337 RK_StdInitializerList,
7350struct IndirectLocalPathEntry {
7364 const Decl *D =
nullptr;
7367 IndirectLocalPathEntry() {}
7368 IndirectLocalPathEntry(EntryKind K,
Expr *E) :
Kind(K), E(E) {}
7369 IndirectLocalPathEntry(EntryKind K,
Expr *E,
const Decl *D)
7370 :
Kind(K), E(E), D(D) {}
7377struct RevertToOldSizeRAII {
7378 IndirectLocalPath &Path;
7379 unsigned OldSize = Path.size();
7380 RevertToOldSizeRAII(IndirectLocalPath &Path) : Path(Path) {}
7381 ~RevertToOldSizeRAII() { Path.resize(OldSize); }
7384using LocalVisitor = llvm::function_ref<
bool(IndirectLocalPath &Path, Local L,
7390 if (E.Kind == IndirectLocalPathEntry::VarInit && E.D == VD)
7396 return llvm::any_of(Path, [=](IndirectLocalPathEntry E) {
7397 return E.Kind == IndirectLocalPathEntry::DefaultInit ||
7398 E.Kind == IndirectLocalPathEntry::VarInit;
7404 bool RevisitSubinits,
7405 bool EnableLifetimeWarnings);
7410 bool EnableLifetimeWarnings);
7425 if (
const auto *ND = dyn_cast<NamespaceDecl>(DC))
7427 StringRef Name = II->getName();
7428 if (Name.size() >= 2 && Name.front() ==
'_' &&
7437 if (
auto *Conv = dyn_cast_or_null<CXXConversionDecl>(Callee))
7438 if (isRecordWithAttr<PointerAttr>(Conv->getConversionType()))
7442 if (!isRecordWithAttr<PointerAttr>(
7443 Callee->getFunctionObjectParameterType()) &&
7444 !isRecordWithAttr<OwnerAttr>(Callee->getFunctionObjectParameterType()))
7446 if (Callee->getReturnType()->isPointerType() ||
7447 isRecordWithAttr<PointerAttr>(Callee->getReturnType())) {
7448 if (!Callee->getIdentifier())
7450 return llvm::StringSwitch<bool>(Callee->getName())
7451 .Cases(
"begin",
"rbegin",
"cbegin",
"crbegin",
true)
7452 .Cases(
"end",
"rend",
"cend",
"crend",
true)
7453 .Cases(
"c_str",
"data",
"get",
true)
7455 .Cases(
"find",
"equal_range",
"lower_bound",
"upper_bound",
true)
7457 }
else if (Callee->getReturnType()->isReferenceType()) {
7458 if (!Callee->getIdentifier()) {
7459 auto OO = Callee->getOverloadedOperator();
7460 return OO == OverloadedOperatorKind::OO_Subscript ||
7461 OO == OverloadedOperatorKind::OO_Star;
7463 return llvm::StringSwitch<bool>(Callee->getName())
7464 .Cases(
"front",
"back",
"at",
"top",
"value",
true)
7481 return llvm::StringSwitch<bool>(FD->
getName())
7482 .Cases(
"begin",
"rbegin",
"cbegin",
"crbegin",
true)
7483 .Cases(
"end",
"rend",
"cend",
"crend",
true)
7487 return llvm::StringSwitch<bool>(FD->
getName())
7488 .Cases(
"get",
"any_cast",
true)
7495 LocalVisitor Visit) {
7496 auto VisitPointerArg = [&](
const Decl *D,
Expr *Arg,
bool Value) {
7499 if (isa<MemberExpr>(Arg->IgnoreImpCasts()))
7503 for (
const IndirectLocalPathEntry &PE : llvm::reverse(Path)) {
7504 if (PE.Kind == IndirectLocalPathEntry::GslReferenceInit)
7506 if (PE.Kind == IndirectLocalPathEntry::GslPointerInit)
7511 Path.push_back({
Value ? IndirectLocalPathEntry::GslPointerInit
7512 : IndirectLocalPathEntry::GslReferenceInit,
7514 if (Arg->isGLValue())
7524 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(
Call)) {
7525 const auto *MD = cast_or_null<CXXMethodDecl>(MCE->getDirectCallee());
7527 VisitPointerArg(MD, MCE->getImplicitObjectArgument(),
7528 !MD->getReturnType()->isReferenceType());
7530 }
else if (
auto *OCE = dyn_cast<CXXOperatorCallExpr>(
Call)) {
7532 if (Callee && Callee->isCXXInstanceMember() &&
7534 VisitPointerArg(Callee, OCE->getArg(0),
7535 !Callee->getReturnType()->isReferenceType());
7537 }
else if (
auto *CE = dyn_cast<CallExpr>(
Call)) {
7540 VisitPointerArg(Callee, CE->getArg(0),
7541 !Callee->getReturnType()->isReferenceType());
7545 if (
auto *CCE = dyn_cast<CXXConstructExpr>(
Call)) {
7546 const auto *Ctor = CCE->getConstructor();
7548 if (CCE->getNumArgs() > 0 && RD->
hasAttr<PointerAttr>())
7549 VisitPointerArg(Ctor->getParamDecl(0), CCE->getArgs()[0],
true);
7577 auto *MD = dyn_cast<CXXMethodDecl>(FD);
7578 if (MD && MD->isCXXInstanceMember())
7581 LHST = MD->getParamDecl(0)->getType();
7591 LocalVisitor Visit) {
7595 if (
auto *CE = dyn_cast<CallExpr>(
Call)) {
7596 Callee = CE->getDirectCallee();
7599 auto *CCE = cast<CXXConstructExpr>(
Call);
7600 Callee = CCE->getConstructor();
7606 Expr *ObjectArg =
nullptr;
7607 if (isa<CXXOperatorCallExpr>(
Call) && Callee->isCXXInstanceMember()) {
7608 ObjectArg = Args[0];
7609 Args = Args.slice(1);
7610 }
else if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(
Call)) {
7611 ObjectArg = MCE->getImplicitObjectArgument();
7614 auto VisitLifetimeBoundArg = [&](
const Decl *D,
Expr *Arg) {
7615 Path.push_back({IndirectLocalPathEntry::LifetimeBoundCall, Arg, D});
7616 if (Arg->isGLValue())
7626 bool CheckCoroCall =
false;
7627 if (
const auto *RD = Callee->getReturnType()->getAsRecordDecl()) {
7628 CheckCoroCall = RD->
hasAttr<CoroLifetimeBoundAttr>() &&
7629 RD->
hasAttr<CoroReturnTypeAttr>() &&
7630 !Callee->hasAttr<CoroDisableLifetimeBoundAttr>();
7634 bool CheckCoroObjArg = CheckCoroCall;
7636 if (
auto *LE = dyn_cast<LambdaExpr>(ObjectArg->
IgnoreImplicit());
7637 LE && LE->captures().empty())
7638 CheckCoroObjArg =
false;
7642 CheckCoroObjArg =
false;
7644 VisitLifetimeBoundArg(Callee, ObjectArg);
7647 for (
unsigned I = 0,
7648 N = std::min<unsigned>(Callee->getNumParams(), Args.size());
7650 if (CheckCoroCall || Callee->getParamDecl(I)->hasAttr<LifetimeBoundAttr>())
7651 VisitLifetimeBoundArg(Callee->getParamDecl(I), Args[I]);
7660 bool EnableLifetimeWarnings) {
7661 RevertToOldSizeRAII RAII(Path);
7668 if (
auto *FE = dyn_cast<FullExpr>(
Init))
7669 Init = FE->getSubExpr();
7679 Init =
const_cast<Expr *
>(
Init->skipRValueSubobjectAdjustments());
7684 if (CE->getSubExpr()->isGLValue())
7685 Init = CE->getSubExpr();
7689 if (
auto *ASE = dyn_cast<ArraySubscriptExpr>(
Init)) {
7690 Init = ASE->getBase();
7691 auto *ICE = dyn_cast<ImplicitCastExpr>(
Init);
7692 if (ICE && ICE->getCastKind() == CK_ArrayToPointerDecay)
7693 Init = ICE->getSubExpr();
7698 EnableLifetimeWarnings);
7703 if (
auto *DIE = dyn_cast<CXXDefaultInitExpr>(
Init)) {
7705 {IndirectLocalPathEntry::DefaultInit, DIE, DIE->getField()});
7706 Init = DIE->getExpr();
7708 }
while (
Init != Old);
7710 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(
Init)) {
7711 if (Visit(Path, Local(MTE), RK))
7713 EnableLifetimeWarnings);
7716 if (isa<CallExpr>(
Init)) {
7717 if (EnableLifetimeWarnings)
7722 switch (
Init->getStmtClass()) {
7723 case Stmt::DeclRefExprClass: {
7726 auto *DRE = cast<DeclRefExpr>(
Init);
7727 auto *VD = dyn_cast<VarDecl>(DRE->getDecl());
7728 if (VD && VD->hasLocalStorage() &&
7729 !DRE->refersToEnclosingVariableOrCapture()) {
7731 Visit(Path, Local(DRE), RK);
7732 }
else if (isa<ParmVarDecl>(DRE->getDecl())) {
7736 }
else if (VD->getInit() && !
isVarOnPath(Path, VD)) {
7737 Path.push_back({IndirectLocalPathEntry::VarInit, DRE, VD});
7739 RK_ReferenceBinding, Visit,
7740 EnableLifetimeWarnings);
7746 case Stmt::UnaryOperatorClass: {
7751 if (
U->getOpcode() == UO_Deref)
7753 EnableLifetimeWarnings);
7757 case Stmt::ArraySectionExprClass: {
7759 cast<ArraySectionExpr>(
Init)->getBase(),
7760 Visit,
true, EnableLifetimeWarnings);
7764 case Stmt::ConditionalOperatorClass:
7765 case Stmt::BinaryConditionalOperatorClass: {
7766 auto *
C = cast<AbstractConditionalOperator>(
Init);
7767 if (!
C->getTrueExpr()->getType()->isVoidType())
7769 EnableLifetimeWarnings);
7770 if (!
C->getFalseExpr()->getType()->isVoidType())
7772 EnableLifetimeWarnings);
7776 case Stmt::CompoundLiteralExprClass: {
7777 if (
auto *CLE = dyn_cast<CompoundLiteralExpr>(
Init)) {
7778 if (!CLE->isFileScope())
7779 Visit(Path, Local(CLE), RK);
7795 bool RevisitSubinits,
7796 bool EnableLifetimeWarnings) {
7797 RevertToOldSizeRAII RAII(Path);
7805 if (
auto *DIE = dyn_cast<CXXDefaultInitExpr>(
Init)) {
7806 Path.push_back({IndirectLocalPathEntry::DefaultInit, DIE, DIE->getField()});
7807 Init = DIE->getExpr();
7810 if (
auto *FE = dyn_cast<FullExpr>(
Init))
7811 Init = FE->getSubExpr();
7814 Init =
const_cast<Expr *
>(
Init->skipRValueSubobjectAdjustments());
7817 Init = BTE->getSubExpr();
7822 if (
auto *CE = dyn_cast<CastExpr>(
Init)) {
7823 switch (CE->getCastKind()) {
7824 case CK_LValueToRValue:
7827 Path.push_back({IndirectLocalPathEntry::LValToRVal, CE});
7829 Path,
Init, RK_ReferenceBinding,
7830 [&](IndirectLocalPath &Path, Local L, ReferenceKind RK) ->
bool {
7831 if (
auto *DRE = dyn_cast<DeclRefExpr>(L)) {
7832 auto *VD = dyn_cast<VarDecl>(DRE->getDecl());
7835 Path.push_back({IndirectLocalPathEntry::VarInit, DRE, VD});
7837 EnableLifetimeWarnings);
7839 }
else if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(L)) {
7840 if (MTE->getType().isConstQualified())
7842 true, EnableLifetimeWarnings);
7845 }, EnableLifetimeWarnings);
7853 case CK_BaseToDerived:
7854 case CK_DerivedToBase:
7855 case CK_UncheckedDerivedToBase:
7858 case CK_UserDefinedConversion:
7859 case CK_ConstructorConversion:
7860 case CK_IntegralToPointer:
7861 case CK_PointerToIntegral:
7862 case CK_VectorSplat:
7863 case CK_IntegralCast:
7864 case CK_CPointerToObjCPointerCast:
7865 case CK_BlockPointerToObjCPointerCast:
7866 case CK_AnyPointerToBlockPointerCast:
7867 case CK_AddressSpaceConversion:
7870 case CK_ArrayToPointerDecay:
7873 Path.push_back({IndirectLocalPathEntry::AddressOf, CE});
7875 RK_ReferenceBinding, Visit,
7876 EnableLifetimeWarnings);
7882 Init = CE->getSubExpr();
7884 }
while (Old !=
Init);
7889 if (
auto *ILE = dyn_cast<CXXStdInitializerListExpr>(
Init))
7891 RK_StdInitializerList, Visit,
7892 EnableLifetimeWarnings);
7898 if (!RevisitSubinits)
7904 EnableLifetimeWarnings);
7907 for (
unsigned I = 0, N = ILE->
getNumInits(); I != N; ++I)
7910 EnableLifetimeWarnings);
7915 assert(RD->isAggregate() &&
"aggregate init on non-aggregate");
7923 RK_ReferenceBinding, Visit,
7924 EnableLifetimeWarnings);
7927 for (; Index < RD->getNumBases() && Index < ILE->getNumInits(); ++Index)
7930 EnableLifetimeWarnings);
7931 for (
const auto *I : RD->
fields()) {
7934 if (I->isUnnamedBitField())
7937 if (I->getType()->isReferenceType())
7939 RK_ReferenceBinding, Visit,
7940 EnableLifetimeWarnings);
7947 EnableLifetimeWarnings);
7957 if (
auto *LE = dyn_cast<LambdaExpr>(
Init)) {
7959 for (
Expr *E : LE->capture_inits()) {
7960 assert(CapI != LE->capture_end());
7965 Path.push_back({IndirectLocalPathEntry::LambdaCaptureInit, E, &Cap});
7968 Visit, EnableLifetimeWarnings);
7971 EnableLifetimeWarnings);
7979 if (
auto *CCE = dyn_cast<CXXConstructExpr>(
Init)) {
7980 if (CCE->getConstructor()->isCopyOrMoveConstructor()) {
7981 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(CCE->getArg(0))) {
7982 Expr *Arg = MTE->getSubExpr();
7983 Path.push_back({IndirectLocalPathEntry::TemporaryCopy, Arg,
7984 CCE->getConstructor()});
7992 if (isa<CallExpr>(
Init) || isa<CXXConstructExpr>(
Init)) {
7993 if (EnableLifetimeWarnings)
7998 switch (
Init->getStmtClass()) {
7999 case Stmt::UnaryOperatorClass: {
8000 auto *UO = cast<UnaryOperator>(
Init);
8003 if (UO->getOpcode() == UO_AddrOf) {
8007 if (isa<MaterializeTemporaryExpr>(UO->getSubExpr()))
8010 Path.push_back({IndirectLocalPathEntry::AddressOf, UO});
8012 RK_ReferenceBinding, Visit,
8013 EnableLifetimeWarnings);
8018 case Stmt::BinaryOperatorClass: {
8020 auto *BO = cast<BinaryOperator>(
Init);
8022 if (!BO->getType()->isPointerType() || (BOK != BO_Add && BOK != BO_Sub))
8025 if (BO->getLHS()->getType()->isPointerType())
8027 EnableLifetimeWarnings);
8028 else if (BO->getRHS()->getType()->isPointerType())
8030 EnableLifetimeWarnings);
8034 case Stmt::ConditionalOperatorClass:
8035 case Stmt::BinaryConditionalOperatorClass: {
8036 auto *
C = cast<AbstractConditionalOperator>(
Init);
8039 if (!
C->getTrueExpr()->getType()->isVoidType())
8041 EnableLifetimeWarnings);
8042 if (!
C->getFalseExpr()->getType()->isVoidType())
8044 EnableLifetimeWarnings);
8048 case Stmt::BlockExprClass:
8049 if (cast<BlockExpr>(
Init)->getBlockDecl()->hasCaptures()) {
8051 Visit(Path, Local(cast<BlockExpr>(
Init)), RK_ReferenceBinding);
8055 case Stmt::AddrLabelExprClass:
8057 Visit(Path, Local(cast<AddrLabelExpr>(
Init)), RK_ReferenceBinding);
8083 for (
auto Elem : Path) {
8084 if (Elem.Kind == IndirectLocalPathEntry::DefaultInit)
8085 Kind = PathLifetimeKind::ShouldExtend;
8086 else if (Elem.Kind != IndirectLocalPathEntry::LambdaCaptureInit)
8087 return PathLifetimeKind::NoExtend;
8095 for (
unsigned N = Path.size(); I != N; ++I) {
8096 switch (Path[I].Kind) {
8097 case IndirectLocalPathEntry::AddressOf:
8098 case IndirectLocalPathEntry::LValToRVal:
8099 case IndirectLocalPathEntry::LifetimeBoundCall:
8100 case IndirectLocalPathEntry::TemporaryCopy:
8101 case IndirectLocalPathEntry::GslReferenceInit:
8102 case IndirectLocalPathEntry::GslPointerInit:
8107 case IndirectLocalPathEntry::VarInit:
8108 if (cast<VarDecl>(Path[I].D)->isImplicit())
8111 case IndirectLocalPathEntry::DefaultInit:
8112 return Path[I].E->getSourceRange();
8114 case IndirectLocalPathEntry::LambdaCaptureInit:
8115 if (!Path[I].
Capture->capturesVariable())
8117 return Path[I].E->getSourceRange();
8124 for (
const auto &It : llvm::reverse(Path)) {
8125 if (It.Kind == IndirectLocalPathEntry::VarInit)
8127 if (It.Kind == IndirectLocalPathEntry::AddressOf)
8129 if (It.Kind == IndirectLocalPathEntry::LifetimeBoundCall)
8131 return It.Kind == IndirectLocalPathEntry::GslPointerInit ||
8132 It.Kind == IndirectLocalPathEntry::GslReferenceInit;
8140 LifetimeKind LK = LR.getInt();
8145 if (LK == LK_FullExpression)
8148 auto TemporaryVisitor = [&](IndirectLocalPath &Path, Local L,
8149 ReferenceKind RK) ->
bool {
8153 auto *MTE = dyn_cast<MaterializeTemporaryExpr>(L);
8155 bool IsGslPtrInitWithGslTempOwner =
false;
8156 bool IsLocalGslOwner =
false;
8158 if (isa<DeclRefExpr>(L)) {
8164 IsLocalGslOwner = isRecordWithAttr<OwnerAttr>(L->getType());
8168 IsGslPtrInitWithGslTempOwner = MTE && !MTE->getExtendingDecl() &&
8169 isRecordWithAttr<OwnerAttr>(MTE->getType());
8173 if (!IsGslPtrInitWithGslTempOwner)
8179 case LK_FullExpression:
8180 llvm_unreachable(
"already handled this");
8192 if (IsGslPtrInitWithGslTempOwner && DiagLoc.
isValid()) {
8193 Diag(DiagLoc, diag::warn_dangling_lifetime_pointer) << DiagRange;
8198 case PathLifetimeKind::Extend:
8201 MTE->setExtendingDecl(ExtendingEntity->
getDecl(),
8206 case PathLifetimeKind::ShouldExtend:
8213 Diag(DiagLoc, diag::warn_unsupported_lifetime_extension)
8217 case PathLifetimeKind::NoExtend:
8224 Diag(DiagLoc, diag::warn_dangling_variable)
8227 << ExtendingEntity->
getDecl() <<
Init->isGLValue() << DiagRange;
8233 case LK_MemInitializer: {
8234 if (isa<MaterializeTemporaryExpr>(L)) {
8238 if (
auto *ExtendingDecl =
8239 ExtendingEntity ? ExtendingEntity->
getDecl() :
nullptr) {
8240 if (IsGslPtrInitWithGslTempOwner) {
8241 Diag(DiagLoc, diag::warn_dangling_lifetime_pointer_member)
8242 << ExtendingDecl << DiagRange;
8243 Diag(ExtendingDecl->getLocation(),
8244 diag::note_ref_or_ptr_member_declared_here)
8248 bool IsSubobjectMember = ExtendingEntity != &Entity;
8250 PathLifetimeKind::NoExtend
8251 ? diag::err_dangling_member
8252 : diag::warn_dangling_member)
8253 << ExtendingDecl << IsSubobjectMember << RK << DiagRange;
8258 Path.back().Kind != IndirectLocalPathEntry::DefaultInit) {
8259 Diag(ExtendingDecl->getLocation(),
8260 diag::note_lifetime_extending_member_declared_here)
8261 << RK << IsSubobjectMember;
8284 auto *DRE = dyn_cast<DeclRefExpr>(L);
8285 auto *VD = DRE ? dyn_cast<VarDecl>(DRE->getDecl()) :
nullptr;
8293 ExtendingEntity ? ExtendingEntity->
getDecl() :
nullptr) {
8294 bool IsPointer = !
Member->getType()->isReferenceType();
8295 Diag(DiagLoc, IsPointer ? diag::warn_init_ptr_member_to_parameter_addr
8296 : diag::warn_bind_ref_member_to_parameter)
8297 << Member << VD << isa<ParmVarDecl>(VD) << DiagRange;
8299 diag::note_ref_or_ptr_member_declared_here)
8307 if (isa<MaterializeTemporaryExpr>(L)) {
8308 if (IsGslPtrInitWithGslTempOwner)
8309 Diag(DiagLoc, diag::warn_dangling_lifetime_pointer) << DiagRange;
8311 Diag(DiagLoc, RK == RK_ReferenceBinding
8312 ? diag::warn_new_dangling_reference
8313 : diag::warn_new_dangling_initializer_list)
8322 case LK_StmtExprResult:
8323 if (
auto *DRE = dyn_cast<DeclRefExpr>(L)) {
8326 if (LK == LK_StmtExprResult)
8328 Diag(DiagLoc, diag::warn_ret_stack_addr_ref)
8330 << isa<ParmVarDecl>(DRE->getDecl()) << DiagRange;
8331 }
else if (isa<BlockExpr>(L)) {
8332 Diag(DiagLoc, diag::err_ret_local_block) << DiagRange;
8333 }
else if (isa<AddrLabelExpr>(L)) {
8336 if (LK == LK_StmtExprResult)
8338 Diag(DiagLoc, diag::warn_ret_addr_label) << DiagRange;
8339 }
else if (
auto *CLE = dyn_cast<CompoundLiteralExpr>(L)) {
8340 Diag(DiagLoc, diag::warn_ret_stack_addr_ref)
8350 Diag(DiagLoc, diag::err_ret_local_temp_ref)
8353 Diag(DiagLoc, diag::warn_ret_local_temp_addr_ref)
8359 for (
unsigned I = 0; I != Path.size(); ++I) {
8360 auto Elem = Path[I];
8362 switch (Elem.Kind) {
8363 case IndirectLocalPathEntry::AddressOf:
8364 case IndirectLocalPathEntry::LValToRVal:
8369 case IndirectLocalPathEntry::LifetimeBoundCall:
8370 case IndirectLocalPathEntry::TemporaryCopy:
8371 case IndirectLocalPathEntry::GslPointerInit:
8372 case IndirectLocalPathEntry::GslReferenceInit:
8376 case IndirectLocalPathEntry::DefaultInit: {
8377 auto *FD = cast<FieldDecl>(Elem.D);
8378 Diag(FD->
getLocation(), diag::note_init_with_default_member_initializer)
8383 case IndirectLocalPathEntry::VarInit: {
8384 const VarDecl *VD = cast<VarDecl>(Elem.D);
8392 case IndirectLocalPathEntry::LambdaCaptureInit:
8393 if (!Elem.Capture->capturesVariable())
8397 const ValueDecl *VD = Elem.Capture->getCapturedVar();
8398 Diag(Elem.Capture->getLocation(), diag::note_lambda_capture_initializer)
8400 << (Elem.Capture->getCaptureKind() ==
LCK_ByRef) << VD
8414 if (
Init->isGLValue())
8417 EnableLifetimeWarnings);
8420 EnableLifetimeWarnings);
8427 const Expr *PostInit);
8434 bool IsReturnStmt) {
8445 unsigned DiagID = 0;
8475 if (VD->
hasAttr<BlocksAttr>())
8488 if (isa<ParmVarDecl>(VD))
8489 DiagID = diag::warn_redundant_move_on_return;
8491 DiagID = diag::warn_pessimizing_move_on_return;
8493 DiagID = diag::warn_pessimizing_move_on_initialization;
8535 if (UO->getOpcode() == UO_Deref &&
8536 UO->getSubExpr()->IgnoreParenCasts()->
8539 S.
PDiag(diag::warn_binding_null_to_reference)
8540 << UO->getSubExpr()->getSourceRange());
8546 bool BoundToLvalueReference) {
8559 Record.ForRangeLifetimeExtendTemps.push_back(MTE);
8591 if (!PointeeTy.isNull() &&
8592 PointeeTy.getAddressSpace() != ExprPointeeTy.getAddressSpace())
8593 CK = CK_AddressSpaceConversion;
8595 CK = CK_AddressSpaceConversion;
8610 if (!ZeroInitializationFixit.empty()) {
8612 const auto *VD = dyn_cast_or_null<VarDecl>(D);
8618 if (!DestType->
isRecordType() && VD && VD->isConstexpr()) {
8620 S.
Diag(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)
8623 ZeroInitializationFixit);
8625 unsigned DiagID = diag::err_default_init_const;
8627 DiagID = diag::ext_default_init_const;
8629 S.
Diag(Kind.getLocation(), DiagID)
8632 ZeroInitializationFixit);
8652 if (isa<InitListExpr>((
Expr *)Args[0])) {
8656 if (
auto *DD = dyn_cast_or_null<DeclaratorDecl>(Entity.
getDecl())) {
8658 TypeLoc TL = TInfo->getTypeLoc();
8661 Brackets = ArrayLoc.getBracketsRange();
8668 ArrayT->getSizeModifier(),
8669 ArrayT->getIndexTypeCVRQualifiers(),
8676 !Kind.isExplicitCast()) {
8678 SourceRange ParenRange = Kind.getParenOrBraceRange();
8683 Kind.isExplicitCast() ||
8693 Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
8699 S.
Diag(
Init->getBeginLoc(), diag::warn_cxx98_compat_reference_list_init)
8700 <<
Init->getSourceRange();
8703 if (S.
getLangOpts().MicrosoftExt && Args.size() == 1 &&
8709 S.
Diag(
Init->getBeginLoc(), diag::ext_init_from_predefined) <<
Init;
8720 S.
Diag(Args[0]->getBeginLoc(), diag::err_opencl_atomic_init)
8740 isa<InitListExpr>(Args[0]);
8741 (void)IsHLSLVectorInit;
8746 switch (Steps.front().Kind) {
8780 assert(Args.size() == 1 || IsHLSLVectorInit);
8799 CurInit.
get() && isa<InitListExpr>(CurInit.
get()));
8804 auto checkAbstractType = [&](
QualType T) ->
bool {
8809 diag::err_allocation_of_abstract_type);
8814 bool ConstructorInitRequiresZeroInit =
false;
8847 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
8859 CK_DerivedToBase, CurInit.
get(),
8875 if (
auto *DRE = dyn_cast<DeclRefExpr>(CurInit.
get()->
IgnoreParens())) {
8876 if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
8889 assert(CurInit.
get()->
isPRValue() &&
"not a temporary");
8947 bool CreatedObject =
false;
8963 Loc,
Step->
Type, FoundFn, Constructor, ConstructorArgs,
8964 HadMultipleCandidates,
8976 CastKind = CK_ConstructorConversion;
8977 CreatedObject =
true;
8987 HadMultipleCandidates);
8991 CastKind = CK_UserDefinedConversion;
8995 if (CreatedObject && checkAbstractType(CurInit.
get()->
getType()))
9016 S.
PDiag(diag::err_access_dtor_temp) <<
T);
9040 "function reference should be lvalue");
9046 assert(CurInit.
get()->
isPRValue() &&
"cannot convert glvalue to atomic");
9054 if (
const auto *FromPtrType =
9057 if (FromPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
9058 !ToPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
9061 if (!Kind.isStaticCast()) {
9063 diag::warn_noderef_to_dereferenceable_pointer)
9083 CurInit = CurInitExprRes;
9104 InitListChecker PerformInitList(S, InitEntity,
9105 InitList, Ty,
false,
9107 if (PerformInitList.HadError())
9115 if ((*ResultType)->isRValueReferenceType())
9117 else if ((*ResultType)->isLValueReferenceType())
9124 PerformInitList.getFullyStructuredList();
9128 : StructuredInitList;
9145 assert(Args.size() == 1 &&
"expected a single argument for list init");
9147 S.
Diag(InitList->
getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
9153 ConstructorInitRequiresZeroInit,
9162 CurInit = cast<InitListExpr>(CurInit.
get())->getInit(0);
9191 bool IsStdInitListInit =
9195 ? Kind.getParenOrBraceRange()
9198 S, UseTemporary ? TempEntity : Entity, Kind,
9200 ConstructorInitRequiresZeroInit,
9211 if (NextStep != StepEnd &&
9216 ConstructorInitRequiresZeroInit =
true;
9219 !Kind.isImplicitValueInit()) {
9223 Kind.getRange().getBegin());
9227 Kind.getRange().getEnd());
9256 CurInit = CurInitExprRes;
9271 S.
Diag(Kind.getLocation(), diag::err_c23_constexpr_pointer_not_null);
9278 InitialCurInit.
get(),
9281 PrintInitLocationNote(S, Entity);
9283 }
else if (Complained)
9284 PrintInitLocationNote(S, Entity);
9300 CK_ObjCObjectLValueCast,
9312 BaseExpr, Kind.getLocation(), IndexExpr, Kind.getLocation());
9313 ArrayLoopCommonExprs.push_back(BaseExpr);
9318 assert(!ArrayLoopCommonExprs.empty() &&
9319 "mismatched SK_ArrayLoopIndex and SK_ArrayLoopInit");
9320 Expr *Common = ArrayLoopCommonExprs.pop_back_val();
9329 S.
Diag(Kind.getLocation(), diag::ext_array_init_copy)
9343 IncompleteDest->getElementType(), ConstantSource->getSize(),
9353 S.
Diag(Kind.getLocation(), diag::ext_array_init_parens)
9373 diag::warn_cxx98_compat_initializer_list_init)
9408 "Sampler initialization on non-sampler type.");
9414 S.
Diag(Kind.getLocation(), diag::err_sampler_argument_required)
9418 auto Var = cast<VarDecl>(DRE->getDecl());
9421 if (!Var->hasGlobalStorage()) {
9433 if (!Var->getInit() || !isa<ImplicitCastExpr>(Var->getInit()))
9435 Init = cast<ImplicitCastExpr>(
const_cast<Expr*
>(
9436 Var->getInit()))->getSubExpr();
9437 SourceType =
Init->getType();
9444 if (!
Init->isConstantInitializer(S.
Context,
false))
9449 S.
Diag(Kind.getLocation(), diag::err_sampler_initializer_not_integer)
9457 const uint64_t SamplerValue =
Result.getLimitedValue();
9464 unsigned AddressingMode = (0x0E & SamplerValue) >> 1;
9465 unsigned FilterMode = (0x30 & SamplerValue) >> 4;
9466 if (FilterMode != 1 && FilterMode != 2 &&
9468 "cl_intel_device_side_avc_motion_estimation", S.
getLangOpts()))
9469 S.
Diag(Kind.getLocation(),
9470 diag::warn_sampler_initializer_invalid_bits)
9472 if (AddressingMode > 4)
9473 S.
Diag(Kind.getLocation(),
9474 diag::warn_sampler_initializer_invalid_bits)
9475 <<
"Addressing Mode";
9481 CK_IntToOCLSampler);
9487 "Wrong type for initialization of OpenCL opaque type.");
9490 CK_ZeroToOCLOpaqueType,
9498 if (CurInit.
get() && ResultType)
9519 cast<FieldDecl>(Entity.
getDecl())->isBitField())
9520 S.CheckBitFieldInitialization(Kind.getLocation(),
9535 S.
Diag(
Loc, diag::err_reference_without_init)
9536 <<
T.getNonReferenceType();
9544 for (
const auto *FI : RD->
fields()) {
9545 if (FI->isUnnamedBitField())
9549 S.
Diag(
Loc, diag::note_value_initialization_here) << RD;
9554 for (
const auto &BI : RD->
bases()) {
9556 S.
Diag(
Loc, diag::note_value_initialization_here) << RD;
9591 if (fromDecl && destDecl && fromDecl->getDeclKind() == Decl::CXXRecord &&
9592 destDecl->getDeclKind() == Decl::CXXRecord &&
9593 !fromDecl->isInvalidDecl() && !destDecl->isInvalidDecl() &&
9594 !fromDecl->hasDefinition() &&
9597 S.
Diag(fromDecl->getLocation(), diag::note_forward_class_conversion)
9625 if (
auto *D = Entity.
getDecl())
9626 Loc = D->getLocation();
9627 S.
Diag(
Loc, diag::note_in_reference_temporary_list_initializer) <<
T;
9631 InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
9634 assert(DiagnoseInitList.HadError() &&
9635 "Inconsistent init list check result.");
9650 if (Args.size() == 1) {
9651 auto *List = dyn_cast<InitListExpr>(Args[0]);
9652 if (List && List->getNumInits() == 1)
9653 OnlyArg = List->getInit(0);
9662 if (
Expr *Resolved =
9682 assert(Diagnosed &&
"couldn't find uninitialized reference to diagnose");
9685 S.
Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
9686 <<
SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
9689 S.
Diag(Kind.getLocation(), diag::err_list_init_in_parens)
9690 << 1 << Entity.
getType() << Args[0]->getSourceRange();
9694 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
9697 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
9700 S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
9703 S.
Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
9706 S.
Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
9709 S.
Diag(Kind.getLocation(),
9710 diag::err_array_init_incompat_wide_string_into_wchar);
9713 S.
Diag(Kind.getLocation(),
9714 diag::err_array_init_plain_string_into_char8_t);
9715 S.
Diag(Args.front()->getBeginLoc(),
9716 diag::note_array_init_plain_string_into_char8_t)
9720 S.
Diag(Kind.getLocation(), diag::err_array_init_utf8_string_into_char)
9725 S.
Diag(Kind.getLocation(),
9727 ? diag::err_array_init_different_type
9728 : diag::err_array_init_non_constant_array))
9731 << Args[0]->getSourceRange();
9735 S.
Diag(Kind.getLocation(), diag::err_variable_object_no_init)
9736 << Args[0]->getSourceRange();
9749 auto *FD = cast<FunctionDecl>(cast<DeclRefExpr>(OnlyArg)->getDecl());
9757 switch (FailedOverloadResult) {
9764 ? (S.
PDiag(diag::err_typecheck_ambiguous_condition)
9765 << OnlyArg->
getType() << DestType
9766 << Args[0]->getSourceRange())
9767 : (S.
PDiag(diag::err_ref_init_ambiguous)
9768 << DestType << OnlyArg->
getType()
9769 << Args[0]->getSourceRange())),
9777 diag::err_typecheck_nonviable_condition_incomplete,
9778 OnlyArg->
getType(), Args[0]->getSourceRange()))
9779 S.
Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
9781 << OnlyArg->
getType() << Args[0]->getSourceRange()
9793 S.
Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
9795 << (Msg !=
nullptr) << (Msg ? Msg->
getString() : StringRef())
9796 << Args[0]->getSourceRange();
9800 llvm_unreachable(
"Inconsistent overload resolution?");
9806 llvm_unreachable(
"Conversion did not fail!");
9811 if (isa<InitListExpr>(Args[0])) {
9812 S.
Diag(Kind.getLocation(),
9813 diag::err_lvalue_reference_bind_to_initlist)
9816 << Args[0]->getSourceRange();
9822 S.
Diag(Kind.getLocation(),
9824 ? diag::err_lvalue_reference_bind_to_temporary
9825 : diag::err_lvalue_reference_bind_to_unrelated)
9829 << Args[0]->getSourceRange();
9834 FieldDecl *BitField = Args[0]->getSourceBitField();
9835 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
9838 << (BitField !=
nullptr)
9839 << Args[0]->getSourceRange();
9846 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
9848 << Args[0]->getSourceRange();
9852 S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_matrix_element)
9857 S.
Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
9859 << Args[0]->getSourceRange();
9863 S.
Diag(Kind.getLocation(), diag::err_reference_bind_temporary_addrspace)
9864 << DestType << Args[0]->getSourceRange();
9875 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
9876 << NonRefType << SourceType << 1
9877 << Args[0]->getSourceRange();
9879 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
9880 << NonRefType << SourceType << 0
9886 S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
9887 << NonRefType << SourceType << 2
9888 << Args[0]->getSourceRange();
9893 S.
Diag(Kind.getLocation(), diag::err_reference_bind_failed)
9898 << Args[0]->getSourceRange();
9909 << Args[0]->getSourceRange();
9911 S.
Diag(Kind.getLocation(), PDiag);
9923 auto *InitList = dyn_cast<InitListExpr>(Args[0]);
9924 if (InitList && InitList->getNumInits() >= 1) {
9925 R =
SourceRange(InitList->getInit(0)->getEndLoc(), InitList->getEndLoc());
9927 assert(Args.size() > 1 &&
"Expected multiple initializers!");
9928 R =
SourceRange(Args.front()->getEndLoc(), Args.back()->getEndLoc());
9932 if (Kind.isCStyleOrFunctionalCast())
9933 S.
Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
9936 S.
Diag(Kind.getLocation(), diag::err_excess_initializers)
9942 S.
Diag(Kind.getLocation(), diag::err_list_init_in_parens)
9943 << 0 << Entity.
getType() << Args[0]->getSourceRange();
9947 S.
Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
9952 S.
Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
9953 << (DestType->
isRecordType()) << DestType << Args[0]->getSourceRange();
9961 SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
9964 assert(Args.size() == 1 &&
9965 "List construction from other than 1 argument.");
9972 switch (FailedOverloadResult) {
9976 S.
PDiag(diag::err_ovl_ambiguous_init)
9977 << DestType << ArgsRange),
9994 if (
auto Inherited = Constructor->getInheritedConstructor())
9995 InheritedFrom = Inherited.getShadowDecl()->getNominatedBaseClass();
9997 S.
Diag(Kind.getLocation(), diag::err_missing_default_ctor)
9998 << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
10010 S.
Diag(Kind.getLocation(), diag::err_missing_default_ctor)
10011 << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
10017 diag::note_member_declared_at);
10022 diag::note_previous_decl)
10030 Kind.getLocation(),
10031 S.
PDiag(diag::err_ovl_no_viable_function_in_init)
10032 << DestType << ArgsRange),
10041 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
10042 << DestType << ArgsRange;
10043 llvm_unreachable(
"Inconsistent overload resolution?");
10051 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
10052 << llvm::to_underlying(
10054 << DestType << ArgsRange;
10057 S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
10058 << DestType << (Msg !=
nullptr)
10059 << (Msg ? Msg->
getString() : StringRef()) << ArgsRange;
10067 llvm_unreachable(
"Conversion did not fail!");
10079 S.
Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
10080 << (Constructor->getInheritedConstructor() ? 2 :
10081 Constructor->isImplicit() ? 1 : 0)
10087 }
else if (
const auto *VD = dyn_cast_if_present<VarDecl>(Entity.
getDecl());
10088 VD && VD->isConstexpr()) {
10089 S.
Diag(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)
10092 S.
Diag(Kind.getLocation(), diag::err_default_init_const)
10099 diag::err_init_incomplete_type);
10115 S.
Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
10116 << Args[0]->getSourceRange();
10121 assert(Ovl ==
OR_Success &&
"Inconsistent overload resolution");
10124 diag::note_explicit_ctor_deduction_guide_here) <<
false;
10135 S.
Diag(Kind.getLocation(), diag::err_designated_init_for_non_aggregate)
10140 PrintInitLocationNote(S, Entity);
10147 OS <<
"Failed sequence: ";
10150 OS <<
"too many initializers for reference";
10154 OS <<
"parenthesized list init for reference";
10158 OS <<
"array requires initializer list";
10162 OS <<
"address of unaddressable function was taken";
10166 OS <<
"array requires initializer list or string literal";
10170 OS <<
"array requires initializer list or wide string literal";
10174 OS <<
"narrow string into wide char array";
10178 OS <<
"wide string into char array";
10182 OS <<
"incompatible wide string into wide char array";
10186 OS <<
"plain string literal into char8_t array";
10190 OS <<
"u8 string literal into char array";
10194 OS <<
"array type mismatch";
10198 OS <<
"non-constant array initializer";
10202 OS <<
"address of overloaded function failed";
10206 OS <<
"overload resolution for reference initialization failed";
10210 OS <<
"non-const lvalue reference bound to temporary";
10214 OS <<
"non-const lvalue reference bound to bit-field";
10218 OS <<
"non-const lvalue reference bound to vector element";
10222 OS <<
"non-const lvalue reference bound to matrix element";
10226 OS <<
"non-const lvalue reference bound to unrelated type";
10230 OS <<
"rvalue reference bound to an lvalue";
10234 OS <<
"reference initialization drops qualifiers";
10238 OS <<
"reference with mismatching address space bound to temporary";
10242 OS <<
"reference initialization failed";
10246 OS <<
"conversion failed";
10250 OS <<
"conversion from property failed";
10254 OS <<
"too many initializers for scalar";
10258 OS <<
"parenthesized list init for reference";
10262 OS <<
"referencing binding to initializer list";
10266 OS <<
"initializer list for non-aggregate, non-scalar type";
10270 OS <<
"overloading failed for user-defined conversion";
10274 OS <<
"constructor overloading failed";
10278 OS <<
"default initialization of a const variable";
10282 OS <<
"initialization of incomplete type";
10286 OS <<
"list initialization checker failure";
10290 OS <<
"variable length array has an initializer";
10294 OS <<
"initializer expression isn't contextually valid";
10298 OS <<
"list constructor overloading failed";
10302 OS <<
"list copy initialization chose explicit constructor";
10306 OS <<
"parenthesized list initialization failed";
10310 OS <<
"designated initializer for non-aggregate type";
10318 OS <<
"Dependent sequence\n";
10322 OS <<
"Normal sequence: ";
10333 OS <<
"resolve address of overloaded function";
10337 OS <<
"derived-to-base (prvalue)";
10341 OS <<
"derived-to-base (xvalue)";
10345 OS <<
"derived-to-base (lvalue)";
10349 OS <<
"bind reference to lvalue";
10353 OS <<
"bind reference to a temporary";
10357 OS <<
"final copy in class direct-initialization";
10361 OS <<
"extraneous C++03 copy to temporary";
10365 OS <<
"user-defined conversion via " << *S->Function.Function;
10369 OS <<
"qualification conversion (prvalue)";
10373 OS <<
"qualification conversion (xvalue)";
10377 OS <<
"qualification conversion (lvalue)";
10381 OS <<
"function reference conversion";
10385 OS <<
"non-atomic-to-atomic conversion";
10389 OS <<
"implicit conversion sequence (";
10395 OS <<
"implicit conversion sequence with narrowing prohibited (";
10401 OS <<
"list aggregate initialization";
10405 OS <<
"unwrap reference initializer list";
10409 OS <<
"rewrap reference initializer list";
10413 OS <<
"constructor initialization";
10417 OS <<
"list initialization via constructor";
10421 OS <<
"zero initialization";
10425 OS <<
"C assignment";
10429 OS <<
"string initialization";
10433 OS <<
"Objective-C object conversion";
10437 OS <<
"indexing for array initialization loop";
10441 OS <<
"array initialization loop";
10445 OS <<
"array initialization";
10449 OS <<
"array initialization (GNU extension)";
10453 OS <<
"parenthesized array initialization";
10457 OS <<
"pass by indirect copy and restore";
10461 OS <<
"pass by indirect restore";
10465 OS <<
"Objective-C object retension";
10469 OS <<
"std::initializer_list from initializer list";
10473 OS <<
"list initialization from std::initializer_list";
10477 OS <<
"OpenCL sampler_t from integer constant";
10481 OS <<
"OpenCL opaque type from zero";
10484 OS <<
"initialization from a parenthesized list of values";
10488 OS <<
" [" << S->Type <<
']';
10495 dump(llvm::errs());
10502 const Expr *PostInit) {
10518 auto MakeDiag = [&](
bool IsConstRef,
unsigned DefaultDiagID,
10519 unsigned ConstRefDiagID,
unsigned WarnDiagID) {
10522 if (L.CPlusPlus11 &&
10524 DiagID = IsConstRef ? ConstRefDiagID : DefaultDiagID;
10526 DiagID = WarnDiagID;
10546 MakeDiag(
T != EntityType, diag::ext_init_list_type_narrowing,
10547 diag::ext_init_list_type_narrowing_const_reference,
10548 diag::warn_init_list_type_narrowing)
10550 <<
T.getLocalUnqualifiedType();
10557 diag::ext_init_list_constant_narrowing,
10558 diag::ext_init_list_constant_narrowing_const_reference,
10559 diag::warn_init_list_constant_narrowing)
10568 diag::ext_init_list_variable_narrowing,
10569 diag::ext_init_list_variable_narrowing_const_reference,
10570 diag::warn_init_list_variable_narrowing)
10578 llvm::raw_svector_ostream OS(StaticCast);
10579 OS <<
"static_cast<";
10586 OS << *TT->getDecl();
10595 S.
Diag(PostInit->
getBeginLoc(), diag::note_init_list_narrowing_silence)
10606 Init->IgnoreParenImpCasts(), ToType,
false,
10607 Sema::AllowedExplicit::None,
10623 S.
Diag(
Init->getBeginLoc(), diag::err_c23_constexpr_init_not_representable)
10624 <<
Value.getAsString(S.
Context, PreNarrowingType) << ToType;
10629 S.
Diag(
Init->getBeginLoc(), diag::err_c23_constexpr_init_type_mismatch)
10630 << ToType << FromType;
10640 llvm_unreachable(
"unhandled case in switch");
10652 for (
unsigned I = 0, N = SE->
getLength(); I != N; ++I) {
10657 diag::err_c23_constexpr_init_not_representable)
10671 if (
Init.isInvalid())
10675 assert(InitE &&
"No initialization expression");
10680 return !
Seq.Failed();
10687 bool TopLevelOfInitList,
10688 bool AllowExplicit) {
10689 if (
Init.isInvalid())
10693 assert(InitE &&
"No initialization expression?");
10703 const bool ShouldTrackCopy =
10705 if (ShouldTrackCopy) {
10707 Seq.SetOverloadFailure(
10713 const auto LastStep =
Seq.step_end() - 1;
10714 assert(LastStep->Kind ==
10718 llvm::find_if(
Seq.getFailedCandidateSet(),
10720 return Candidate.Viable &&
10721 Candidate.Function == Function &&
10722 Candidate.Conversions.size() > 0;
10724 if (Candidate !=
Seq.getFailedCandidateSet().end() &&
10726 Candidate->
Viable =
false;
10730 Function->getParamDecl(0)->getType());
10738 if (ShouldTrackCopy)
10747 auto NotSpecialization = [&] (
const CXXRecordDecl *Candidate) {
10748 auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Candidate);
10751 return !(NotSpecialization(RD) && RD->
forallBases(NotSpecialization));
10757 auto *DeducedTST = dyn_cast<DeducedTemplateSpecializationType>(
10759 assert(DeducedTST &&
"not a deduced template specialization type");
10770 if (
auto *
AliasTemplate = dyn_cast_or_null<TypeAliasTemplateDecl>(
10772 Diag(Kind.getLocation(),
10773 diag::warn_cxx17_compat_ctad_for_alias_templates);
10776 ->getUnderlyingType()
10777 .getCanonicalType();
10781 if (
const auto *TST =
10783 Template = dyn_cast_or_null<ClassTemplateDecl>(
10784 TST->getTemplateName().getAsTemplateDecl());
10785 }
else if (
const auto *RT = UnderlyingType->getAs<
RecordType>()) {
10789 if (
const auto *CTSD = llvm::dyn_cast<ClassTemplateSpecializationDecl>(
10790 RT->getAsCXXRecordDecl()))
10791 Template = CTSD->getSpecializedTemplate();
10796 Diag(Kind.getLocation(),
10797 diag::err_deduced_non_class_or_alias_template_specialization_type)
10807 diag::warn_cxx14_compat_class_template_argument_deduction)
10835 ? dyn_cast<InitListExpr>(Inits[0])
10851 bool AllowExplicit = !Kind.isCopyInit() ||
ListInit;
10857 bool OnlyListConstructors,
10858 bool AllowAggregateDeductionCandidate) {
10864 if (!AllowExplicit) {
10871 if (GD->getMinRequiredArguments() > 1 ||
10872 (GD->getNumParams() == 0 && !GD->isVariadic()))
10882 if (!AllowAggregateDeductionCandidate &&
10898 bool SuppressUserConversions = Kind.isCopyInit();
10902 for (
Expr *E : Inits)
10903 if (
auto *DI = dyn_cast<DesignatedInitExpr>(E))
10904 TmpInits.push_back(DI->getInit());
10906 TmpInits.push_back(E);
10908 TD, FoundDecl,
nullptr, TmpInits, Candidates,
10909 SuppressUserConversions,
10910 false, AllowExplicit, ADLCallKind::NotADL,
10911 {}, AllowAggregateDeductionCandidate);
10914 SuppressUserConversions,
10915 false, AllowExplicit);
10919 bool FoundDeductionGuide =
false;
10921 auto TryToResolveOverload =
10924 bool HasAnyDeductionGuide =
false;
10927 auto *Pattern = Template;
10928 while (Pattern->getInstantiatedFromMemberTemplate()) {
10929 if (Pattern->isMemberSpecialization())
10931 Pattern = Pattern->getInstantiatedFromMemberTemplate();
10934 auto *RD = cast<CXXRecordDecl>(Pattern->getTemplatedDecl());
10940 InitListChecker CheckInitList(*
this, Entity,
ListInit, Ty, ElementTypes);
10941 if (!CheckInitList.HadError()) {
10950 for (
int I = 0, E =
ListInit->getNumInits();
10951 I < E && !isa<PackExpansionType>(ElementTypes[I]); ++I)
10952 if (ElementTypes[I]->isArrayType()) {
10953 if (isa<InitListExpr>(
ListInit->getInit(I)))
10955 else if (isa<StringLiteral>(
10956 ListInit->getInit(I)->IgnoreParenImpCasts()))
10963 LookupTemplateDecl, ElementTypes,
10967 OnlyListConstructors,
10969 HasAnyDeductionGuide =
true;
10974 for (
auto I = Guides.
begin(), E = Guides.
end(); I != E; ++I) {
10975 NamedDecl *D = (*I)->getUnderlyingDecl();
10979 auto *TD = dyn_cast<FunctionTemplateDecl>(D);
10980 auto *GD = dyn_cast_if_present<CXXDeductionGuideDecl>(
10985 if (!GD->isImplicit())
10986 HasAnyDeductionGuide =
true;
10988 addDeductionCandidate(TD, GD, I.getPair(), OnlyListConstructors,
11003 }
else if (Inits.size()) {
11008 Inits, Inits.back()->getEndLoc());
11009 SynthesizeAggrGuide(&TempListInit);
11013 FoundDeductionGuide = FoundDeductionGuide || HasAnyDeductionGuide;
11023 bool TryListConstructors =
true;
11029 auto *FD = dyn_cast<FunctionDecl>(D->getUnderlyingDecl());
11030 if (FD && FD->getMinRequiredArguments() == 0) {
11031 TryListConstructors =
false;
11035 }
else if (
ListInit->getNumInits() == 1) {
11043 if (!isa<InitListExpr>(E) && RD &&
11046 TryListConstructors =
false;
11049 if (TryListConstructors)
11050 Result = TryToResolveOverload(
true);
11059 Result = TryToResolveOverload(
false);
11068 Kind.getLocation(),
11069 PDiag(diag::err_deduced_class_template_ctor_ambiguous)
11076 cast<ClassTemplateDecl>(Template)->getTemplatedDecl();
11081 Kind.getLocation(),
11082 PDiag(
Complete ? diag::err_deduced_class_template_ctor_no_viable
11083 : diag::err_deduced_class_template_incomplete)
11093 Diag(Kind.getLocation(), diag::err_deduced_class_template_deleted)
11103 if (Kind.isCopyInit() &&
ListInit &&
11104 cast<CXXDeductionGuideDecl>(Best->Function)->isExplicit()) {
11105 bool IsDeductionGuide = !Best->Function->isImplicit();
11106 Diag(Kind.getLocation(), diag::err_deduced_class_template_explicit)
11108 Diag(Best->Function->getLocation(),
11109 diag::note_explicit_ctor_deduction_guide_here)
11110 << IsDeductionGuide;
11127 diag::warn_cxx14_compat_class_template_argument_deduction)
11132 if (!FoundDeductionGuide) {
11134 diag::warn_ctad_maybe_unsupported)
11136 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.
This file declares semantic analysis for Objective-C.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Defines the clang::TypeLoc interface and its subclasses.
__device__ __2f16 float __ockl_bool s
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
std::string getAsString(const ASTContext &Ctx, QualType Ty) const
bool isNullPointer() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
const ConstantArrayType * getAsConstantArrayType(QualType T) const
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
unsigned getIntWidth(QualType T) const
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
DeclarationNameTable DeclarationNames
QualType getRecordType(const RecordDecl *Decl) const
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
QualType getPackExpansionType(QualType Pattern, std::optional< unsigned > NumExpansions, bool ExpectPackInType=true)
Form a pack expansion type with the given pattern.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
const VariableArrayType * getAsVariableArrayType(QualType T) const
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
const TargetInfo & getTargetInfo() const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
QualType getWideCharType() const
Return the type of wide characters.
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Represents a loop initializing the elements of an array.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
Type source information for an attributed type.
TypeLoc getModifiedLoc() const
The modified type, which is generally canonically different from the attribute type.
This class is used for builtin types like 'int'.
Represents a base class of a C++ class.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
QualType getType() const
Retrieves the type of the base class.
Represents binding an expression to a temporary.
Represents a call to a C++ constructor.
Expr * getArg(unsigned Arg)
Return the specified argument.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Represents a C++ constructor within a class.
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isExplicit() const
Return true if the declaration is already resolved to be explicit.
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Represents a C++ conversion function within a class.
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a C++ deduction guide declaration.
Represents a C++ destructor within a class.
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
static CXXParenListInitExpr * Create(ASTContext &C, ArrayRef< Expr * > Args, QualType T, unsigned NumUserSpecifiedExprs, SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Represents a C++ struct/union/class.
bool hasUninitializedReferenceMember() const
Whether this class or any of its subobjects has any members of reference type which would make value-...
bool allowConstDefaultInit() const
Determine whether declaring a const variable with this type is ok per core issue 253.
llvm::iterator_range< conversion_iterator > getVisibleConversionFunctions() const
Get all conversion functions visible in current class, including conversion function templates.
unsigned getNumBases() const
Retrieves the number of base classes of this class.
llvm::iterator_range< base_class_iterator > base_class_range
llvm::iterator_range< base_class_const_iterator > base_class_const_range
bool forallBases(ForallBasesCallback BaseMatches) const
Determines if the given callback holds for all the direct or indirect base classes of this type.
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type.
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
static CXXTemporaryObjectExpr * Create(const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty, TypeSourceInfo *TSI, ArrayRef< Expr * > Args, SourceRange ParenOrBraceRange, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization)
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
SourceLocation getBeginLoc() const LLVM_READONLY
bool isCallToStdMove() const
SourceLocation getRParenLoc() const
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
SourceLocation getBegin() const
Declaration of a class template.
void setExprNeedsCleanups(bool SideEffects)
Complex values, per C99 6.2.5p11.
QualType getElementType() const
ConditionalOperator - The ?: ternary operator.
Represents the canonical version of C arrays with a specified constant size.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
virtual bool ValidateCandidate(const TypoCorrection &candidate)
Simple predicate used by the default RankCandidate to determine whether to return an edit distance of...
virtual std::unique_ptr< CorrectionCandidateCallback > clone()=0
Clone this CorrectionCandidateCallback.
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
NamedDecl * getDecl() const
The results of name lookup within a DeclContext.
decl_iterator - Iterates through the declarations stored within this context.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
bool isStdNamespace() const
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
A reference to a declared variable, function, enum, etc.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Decl - This represents one declaration (or definition), e.g.
bool isInStdNamespace() const
SourceLocation getEndLoc() const LLVM_READONLY
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isInvalidDecl() const
SourceLocation getLocation() const
DeclContext * getDeclContext()
SourceLocation getBeginLoc() const LLVM_READONLY
The name of a declaration.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
SourceLocation getBeginLoc() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Represents a single C99 designator.
bool isFieldDesignator() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isArrayRangeDesignator() const
void setFieldDecl(FieldDecl *FD)
FieldDecl * getFieldDecl() const
bool isArrayDesignator() const
SourceLocation getFieldLoc() const
const IdentifierInfo * getFieldName() const
SourceLocation getDotLoc() const
SourceLocation getLBracketLoc() const
Represents a C99 designated initializer expression.
bool isDirectInit() const
Whether this designated initializer should result in direct-initialization of the designated subobjec...
Expr * getArrayRangeEnd(const Designator &D) const
Expr * getSubExpr(unsigned Idx) const
llvm::MutableArrayRef< Designator > designators()
bool usesGNUSyntax() const
Determines whether this designated initializer used the deprecated GNU syntax for designated initiali...
Expr * getArrayRangeStart(const Designator &D) const
void ExpandDesignator(const ASTContext &C, unsigned Idx, const Designator *First, const Designator *Last)
Replaces the designator at index Idx with the series of designators in [First, Last).
static DesignatedInitExpr * Create(const ASTContext &C, llvm::ArrayRef< Designator > Designators, ArrayRef< Expr * > IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)
Expr * getArrayIndex(const Designator &D) const
Designator * getDesignator(unsigned Idx)
Expr * getInit() const
Retrieve the initializer value.
unsigned size() const
Returns the number of designators in this initializer.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getEqualOrColonLoc() const
Retrieve the location of the '=' that precedes the initializer value itself, if present.
unsigned getNumSubExprs() const
Retrieve the total number of subexpressions in this designated initializer expression,...
InitListExpr * getUpdater() const
Designation - Represent a full designation, which is a sequence of designators.
const Designator & getDesignator(unsigned Idx) const
unsigned getNumDesignators() const
Designator - A designator in a C99 designated initializer.
SourceLocation getFieldLoc() const
SourceLocation getDotLoc() const
Expr * getArrayRangeStart() const
bool isArrayDesignator() const
SourceLocation getLBracketLoc() const
bool isArrayRangeDesignator() const
bool isFieldDesignator() const
SourceLocation getRBracketLoc() const
SourceLocation getEllipsisLoc() const
Expr * getArrayRangeEnd() const
const IdentifierInfo * getFieldDecl() const
Expr * getArrayIndex() const
static Designator CreateFieldDesignator(const IdentifierInfo *FieldName, SourceLocation DotLoc, SourceLocation FieldLoc)
Creates a field designator.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
RAII object that enters a new expression evaluation context.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
The return type of classify().
This represents one expression.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool refersToVectorElement() const
Returns whether this expression refers to a vector element.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
@ NPC_ValueDependentIsNotNull
Specifies that a value-dependent expression should be considered to never be a null pointer constant.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type.
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
bool refersToMatrixElement() const
Returns whether this expression refers to a matrix element.
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
ExtVectorType - Extended vector type.
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isUnnamedBitField() const
Determines whether this is an unnamed bitfield.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Represents a function declaration or definition.
const ParmVarDecl * getParamDecl(unsigned i) const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
QualType getReturnType() const
bool isDeleted() const
Whether this function has been deleted.
bool isDefaulted() const
Whether this function is defaulted.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Declaration of a template function.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
One of these records is kept for each identifier that is lexed.
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
@ StaticObjectArgumentConversion
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence.
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
static ImplicitConversionSequence getNullptrToBool(QualType SourceType, QualType DestType, bool NeedLValToRVal)
Form an "implicit" conversion sequence from nullptr_t to bool, for a direct-initialization of a bool ...
Represents an implicitly-generated value initialization of an object of a given type.
Represents a C array with an unspecified size.
Represents a field injected from an anonymous union/struct into the parent scope.
chain_iterator chain_end() const
chain_iterator chain_begin() const
ArrayRef< NamedDecl * >::const_iterator chain_iterator
Describes an C or C++ initializer list.
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
void setSyntacticForm(InitListExpr *Init)
void markError()
Mark the semantic form of the InitListExpr as error when the semantic analysis fails.
bool hasDesignatedInit() const
Determine whether this initializer list contains a designated initializer.
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic,...
void resizeInits(const ASTContext &Context, unsigned NumInits)
Specify the number of initializers.
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
unsigned getNumInits() const
SourceLocation getBeginLoc() const LLVM_READONLY
void setInit(unsigned Init, Expr *expr)
SourceLocation getLBraceLoc() const
Expr * updateInit(const ASTContext &C, unsigned Init, Expr *expr)
Updates the initializer at index Init with the new expression expr, and returns the old expression at...
void setArrayFiller(Expr *filler)
InitListExpr * getSyntacticForm() const
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
SourceLocation getRBraceLoc() const
const Expr * getInit(unsigned Init) const
bool isIdiomaticZeroInitializer(const LangOptions &LangOpts) const
Is this the zero initializer {0} in a language which considers it idiomatic?
SourceLocation getEndLoc() const LLVM_READONLY
void setInitializedFieldInUnion(FieldDecl *FD)
bool isSyntacticForm() const
void setRBraceLoc(SourceLocation Loc)
void sawArrayRangeDesignator(bool ARD=true)
Expr ** getInits()
Retrieve the set of initializers.
Describes the kind of initialization being performed, along with location information for tokens rela...
@ IK_DirectList
Direct list-initialization.
@ IK_Value
Value initialization.
@ IK_Direct
Direct initialization.
@ IK_Copy
Copy initialization.
@ IK_Default
Default initialization.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static InitializationKind CreateDirectList(SourceLocation InitLoc)
static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool isImplicit=false)
Create a value initialization.
A single step in the initialization sequence.
StepKind Kind
The kind of conversion or initialization step we are taking.
InitListExpr * WrappingSyntacticList
When Kind = SK_RewrapInitList, the syntactic form of the wrapping list.
ImplicitConversionSequence * ICS
When Kind = SK_ConversionSequence, the implicit conversion sequence.
struct F Function
When Kind == SK_ResolvedOverloadedFunction or Kind == SK_UserConversion, the function that the expres...
Describes the sequence of initializations required to initialize a given object or reference with a s...
step_iterator step_begin() const
void AddListInitializationStep(QualType T)
Add a list-initialization step.
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
void AddStringInitStep(QualType T)
Add a string init step.
void AddStdInitializerListConstructionStep(QualType T)
Add a step to construct a std::initializer_list object from an initializer list.
void AddConstructorInitializationStep(DeclAccessPair FoundDecl, CXXConstructorDecl *Constructor, QualType T, bool HadMultipleCandidates, bool FromInitList, bool AsInitList)
Add a constructor-initialization step.
@ SK_StdInitializerListConstructorCall
Perform initialization via a constructor taking a single std::initializer_list argument.
@ SK_AtomicConversion
Perform a conversion adding _Atomic to a type.
@ SK_ObjCObjectConversion
An initialization that "converts" an Objective-C object (not a point to an object) to another Objecti...
@ SK_GNUArrayInit
Array initialization (from an array rvalue) as a GNU extension.
@ SK_CastDerivedToBaseLValue
Perform a derived-to-base cast, producing an lvalue.
@ SK_ProduceObjCObject
Produce an Objective-C object pointer.
@ SK_FunctionReferenceConversion
Perform a function reference conversion, see [dcl.init.ref]p4.
@ SK_BindReference
Reference binding to an lvalue.
@ SK_ArrayLoopInit
Array initialization by elementwise copy.
@ SK_ConstructorInitialization
Perform initialization via a constructor.
@ SK_OCLSamplerInit
Initialize an OpenCL sampler from an integer.
@ SK_StringInit
Initialization by string.
@ SK_ZeroInitialization
Zero-initialize the object.
@ SK_CastDerivedToBaseXValue
Perform a derived-to-base cast, producing an xvalue.
@ SK_QualificationConversionXValue
Perform a qualification conversion, producing an xvalue.
@ SK_UserConversion
Perform a user-defined conversion, either via a conversion function or via a constructor.
@ SK_CastDerivedToBasePRValue
Perform a derived-to-base cast, producing an rvalue.
@ SK_BindReferenceToTemporary
Reference binding to a temporary.
@ SK_PassByIndirectRestore
Pass an object by indirect restore.
@ SK_ParenthesizedArrayInit
Array initialization from a parenthesized initializer list.
@ SK_ParenthesizedListInit
Initialize an aggreagate with parenthesized list of values.
@ SK_ArrayInit
Array initialization (from an array rvalue).
@ SK_ExtraneousCopyToTemporary
An optional copy of a temporary object to another temporary object, which is permitted (but not requi...
@ SK_ArrayLoopIndex
Array indexing for initialization by elementwise copy.
@ SK_ConversionSequenceNoNarrowing
Perform an implicit conversion sequence without narrowing.
@ SK_RewrapInitList
Rewrap the single-element initializer list for a reference.
@ SK_CAssignment
C assignment.
@ SK_ConstructorInitializationFromList
Perform initialization via a constructor, taking arguments from a single InitListExpr.
@ SK_PassByIndirectCopyRestore
Pass an object by indirect copy-and-restore.
@ SK_ResolveAddressOfOverloadedFunction
Resolve the address of an overloaded function to a specific function declaration.
@ SK_UnwrapInitList
Unwrap the single-element initializer list for a reference.
@ SK_FinalCopy
Direct-initialization from a reference-related object in the final stage of class copy-initialization...
@ SK_QualificationConversionLValue
Perform a qualification conversion, producing an lvalue.
@ SK_StdInitializerList
Construct a std::initializer_list from an initializer list.
@ SK_QualificationConversionPRValue
Perform a qualification conversion, producing a prvalue.
@ SK_ConversionSequence
Perform an implicit conversion sequence.
@ SK_ListInitialization
Perform list-initialization without a constructor.
@ SK_OCLZeroOpaqueType
Initialize an opaque OpenCL type (event_t, queue_t, etc.) with zero.
void AddUserConversionStep(FunctionDecl *Function, DeclAccessPair FoundDecl, QualType T, bool HadMultipleCandidates)
Add a new step invoking a conversion function, which is either a constructor or a conversion function...
void SetZeroInitializationFixit(const std::string &Fixit, SourceLocation L)
Call for initializations are invalid but that would be valid zero initialzations if Fixit was applied...
InitializationSequence(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, bool TopLevelOfInitList=false, bool TreatUnavailableAsInvalid=true)
Try to perform initialization of the given entity, creating a record of the steps required to perform...
void AddQualificationConversionStep(QualType Ty, ExprValueKind Category)
Add a new step that performs a qualification conversion to the given type.
void AddFunctionReferenceConversionStep(QualType Ty)
Add a new step that performs a function reference conversion to the given type.
~InitializationSequence()
void AddDerivedToBaseCastStep(QualType BaseType, ExprValueKind Category)
Add a new step in the initialization that performs a derived-to- base cast.
FailureKind getFailureKind() const
Determine why initialization failed.
void InitializeFrom(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, bool TopLevelOfInitList, bool TreatUnavailableAsInvalid)
void AddParenthesizedListInitStep(QualType T)
void SetFailed(FailureKind Failure)
Note that this initialization sequence failed.
bool isAmbiguous() const
Determine whether this initialization failed due to an ambiguity.
void AddOCLZeroOpaqueTypeStep(QualType T)
Add a step to initialzie an OpenCL opaque type (event_t, queue_t, etc.) from a zero constant.
void AddFinalCopy(QualType T)
Add a new step that makes a copy of the input to an object of the given type, as the final step in cl...
void setSequenceKind(enum SequenceKind SK)
Set the kind of sequence computed.
void AddObjCObjectConversionStep(QualType T)
Add an Objective-C object conversion step, which is always a no-op.
void SetOverloadFailure(FailureKind Failure, OverloadingResult Result)
Note that this initialization sequence failed due to failed overload resolution.
step_iterator step_end() const
void AddParenthesizedArrayInitStep(QualType T)
Add a parenthesized array initialization step.
void AddExtraneousCopyToTemporary(QualType T)
Add a new step that makes an extraneous copy of the input to a temporary of the same class type.
void setIncompleteTypeFailure(QualType IncompleteType)
Note that this initialization sequence failed due to an incomplete type.
void AddOCLSamplerInitStep(QualType T)
Add a step to initialize an OpenCL sampler from an integer constant.
void AddCAssignmentStep(QualType T)
Add a C assignment step.
void AddPassByIndirectCopyRestoreStep(QualType T, bool shouldCopy)
Add a step to pass an object by indirect copy-restore.
void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic)
Add steps to unwrap a initializer list for a reference around a single element and rewrap it at the e...
bool Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr * > Args)
Diagnose an potentially-invalid initialization sequence.
bool Failed() const
Determine whether the initialization sequence is invalid.
void AddAtomicConversionStep(QualType Ty)
Add a new step that performs conversion from non-atomic to atomic type.
void dump() const
Dump a representation of this initialization sequence to standard error, for debugging purposes.
void AddConversionSequenceStep(const ImplicitConversionSequence &ICS, QualType T, bool TopLevelOfInitList=false)
Add a new step that applies an implicit conversion sequence.
void AddZeroInitializationStep(QualType T)
Add a zero-initialization step.
void AddProduceObjCObjectStep(QualType T)
Add a step to "produce" an Objective-C object (by retaining it).
enum SequenceKind getKind() const
Determine the kind of initialization sequence computed.
SequenceKind
Describes the kind of initialization sequence computed.
@ NormalSequence
A normal sequence.
@ FailedSequence
A failed initialization sequence.
@ DependentSequence
A dependent initialization, which could not be type-checked due to the presence of dependent types or...
void AddReferenceBindingStep(QualType T, bool BindingTemporary)
Add a new step binding a reference to an object.
FailureKind
Describes why initialization failed.
@ FK_UserConversionOverloadFailed
Overloading for a user-defined conversion failed.
@ FK_NarrowStringIntoWideCharArray
Initializing a wide char array with narrow string literal.
@ FK_ArrayTypeMismatch
Array type mismatch.
@ FK_ParenthesizedListInitForReference
Reference initialized from a parenthesized initializer list.
@ FK_NonConstLValueReferenceBindingToVectorElement
Non-const lvalue reference binding to a vector element.
@ FK_ReferenceInitDropsQualifiers
Reference binding drops qualifiers.
@ FK_InitListBadDestinationType
Initialization of some unused destination type with an initializer list.
@ FK_ConversionFromPropertyFailed
Implicit conversion failed.
@ FK_NonConstLValueReferenceBindingToUnrelated
Non-const lvalue reference binding to an lvalue of unrelated type.
@ FK_ListConstructorOverloadFailed
Overloading for list-initialization by constructor failed.
@ FK_ReferenceInitFailed
Reference binding failed.
@ FK_DesignatedInitForNonAggregate
@ FK_ArrayNeedsInitList
Array must be initialized with an initializer list.
@ FK_PlainStringIntoUTF8Char
Initializing char8_t array with plain string literal.
@ FK_NonConstantArrayInit
Non-constant array initializer.
@ FK_NonConstLValueReferenceBindingToTemporary
Non-const lvalue reference binding to a temporary.
@ FK_ConversionFailed
Implicit conversion failed.
@ FK_ArrayNeedsInitListOrStringLiteral
Array must be initialized with an initializer list or a string literal.
@ FK_ParenthesizedListInitForScalar
Scalar initialized from a parenthesized initializer list.
@ FK_PlaceholderType
Initializer has a placeholder type which cannot be resolved by initialization.
@ FK_IncompatWideStringIntoWideChar
Initializing wide char array with incompatible wide string literal.
@ FK_NonConstLValueReferenceBindingToMatrixElement
Non-const lvalue reference binding to a matrix element.
@ FK_TooManyInitsForReference
Too many initializers provided for a reference.
@ FK_NonConstLValueReferenceBindingToBitfield
Non-const lvalue reference binding to a bit-field.
@ FK_ReferenceAddrspaceMismatchTemporary
Reference with mismatching address space binding to temporary.
@ FK_ListInitializationFailed
List initialization failed at some point.
@ FK_TooManyInitsForScalar
Too many initializers for scalar.
@ FK_AddressOfOverloadFailed
Cannot resolve the address of an overloaded function.
@ FK_VariableLengthArrayHasInitializer
Variable-length array must not have an initializer.
@ FK_ArrayNeedsInitListOrWideStringLiteral
Array must be initialized with an initializer list or a wide string literal.
@ FK_RValueReferenceBindingToLValue
Rvalue reference binding to an lvalue.
@ FK_Incomplete
Initialization of an incomplete type.
@ FK_WideStringIntoCharArray
Initializing char array with wide string literal.
@ FK_ExplicitConstructor
List-copy-initialization chose an explicit constructor.
@ FK_ReferenceInitOverloadFailed
Overloading due to reference initialization failed.
@ FK_ConstructorOverloadFailed
Overloading for initialization by constructor failed.
@ FK_ReferenceBindingToInitList
Reference initialization from an initializer list.
@ FK_DefaultInitOfConst
Default-initialization of a 'const' object.
@ FK_ParenthesizedListInitFailed
Parenthesized list initialization failed at some point.
@ FK_AddressOfUnaddressableFunction
Trying to take the address of a function that doesn't support having its address taken.
@ FK_UTF8StringIntoPlainChar
Initializing char array with UTF-8 string literal.
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init....
void AddArrayInitLoopStep(QualType T, QualType EltTy)
Add an array initialization loop step.
void AddAddressOverloadResolutionStep(FunctionDecl *Function, DeclAccessPair Found, bool HadMultipleCandidates)
Add a new step in the initialization that resolves the address of an overloaded function to a specifi...
void AddArrayInitStep(QualType T, bool IsGNUExtension)
Add an array initialization step.
bool isConstructorInitialization() const
Determine whether this initialization is direct call to a constructor.
SmallVectorImpl< Step >::const_iterator step_iterator
OverloadCandidateSet & getFailedCandidateSet()
Retrieve a reference to the candidate set when overload resolution fails.
Describes an entity that is being initialized.
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a base class subobject.
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
VD Variable
When Kind == EK_Variable, EK_Member, EK_Binding, or EK_TemplateParameter, the variable,...
EntityKind getKind() const
Determine the kind of initialization.
DeclarationName getName() const
Retrieve the name of the entity being initialized.
unsigned allocateManglingNumber() const
QualType getType() const
Retrieve type being initialized.
ValueDecl * getDecl() const
Retrieve the variable, parameter, or field being initialized.
bool isImplicitMemberInitializer() const
Is this the implicit initialization of a member of a class from a defaulted constructor?
const InitializedEntity * getParent() const
Retrieve the parent of the entity being initialized, when the initialization itself is occurring with...
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
bool isParameterConsumed() const
Determine whether this initialization consumes the parameter.
static InitializedEntity InitializeElement(ASTContext &Context, unsigned Index, const InitializedEntity &Parent)
Create the initialization entity for an array element.
unsigned getElementIndex() const
If this is an array, vector, or complex number element, get the element's index.
void setElementIndex(unsigned Index)
If this is already the initializer for an array or vector element, sets the element index.
SourceLocation getCaptureLoc() const
Determine the location of the capture when initializing field from a captured variable in a lambda.
bool isParamOrTemplateParamKind() const
llvm::PointerIntPair< const CXXBaseSpecifier *, 1 > Base
When Kind == EK_Base, the base specifier that provides the base class.
bool allowsNRVO() const
Determine whether this initialization allows the named return value optimization, which also applies ...
bool isParameterKind() const
void dump() const
Dump a representation of the initialized entity to standard error, for debugging purposes.
EntityKind
Specifies the kind of entity being initialized.
@ EK_Variable
The entity being initialized is a variable.
@ EK_Temporary
The entity being initialized is a temporary object.
@ EK_Binding
The entity being initialized is a structured binding of a decomposition declaration.
@ EK_BlockElement
The entity being initialized is a field of block descriptor for the copied-in c++ object.
@ EK_Parameter_CF_Audited
The entity being initialized is a function parameter; function is member of group of audited CF APIs.
@ EK_LambdaToBlockConversionBlockElement
The entity being initialized is a field of block descriptor for the copied-in lambda object that's us...
@ EK_Member
The entity being initialized is a non-static data member subobject.
@ EK_Base
The entity being initialized is a base member subobject.
@ EK_Result
The entity being initialized is the result of a function call.
@ EK_TemplateParameter
The entity being initialized is a non-type template parameter.
@ EK_StmtExprResult
The entity being initialized is the result of a statement expression.
@ EK_ParenAggInitMember
The entity being initialized is a non-static data member subobject of an object initialized via paren...
@ EK_VectorElement
The entity being initialized is an element of a vector.
@ EK_New
The entity being initialized is an object (or array of objects) allocated via new.
@ EK_CompoundLiteralInit
The entity being initialized is the initializer for a compound literal.
@ EK_Parameter
The entity being initialized is a function parameter.
@ EK_Delegating
The initialization is being done by a delegating constructor.
@ EK_ComplexElement
The entity being initialized is the real or imaginary part of a complex number.
@ EK_ArrayElement
The entity being initialized is an element of an array.
@ EK_LambdaCapture
The entity being initialized is the field that captures a variable in a lambda.
@ EK_Exception
The entity being initialized is an exception object that is being thrown.
@ EK_RelatedResult
The entity being implicitly initialized back to the formal result type.
static InitializedEntity InitializeMemberFromParenAggInit(FieldDecl *Member)
Create the initialization entity for a member subobject initialized via parenthesized aggregate init.
SourceLocation getThrowLoc() const
Determine the location of the 'throw' keyword when initializing an exception object.
unsigned Index
When Kind == EK_ArrayElement, EK_VectorElement, or EK_ComplexElement, the index of the array or vecto...
bool isVariableLengthArrayNew() const
Determine whether this is an array new with an unknown bound.
bool isDefaultMemberInitializer() const
Is this the default member initializer of a member (specified inside the class definition)?
llvm::PointerIntPair< ParmVarDecl *, 1 > Parameter
When Kind == EK_Parameter, the ParmVarDecl, with the integer indicating whether the parameter is "con...
const CXXBaseSpecifier * getBaseSpecifier() const
Retrieve the base specifier.
SourceLocation getReturnLoc() const
Determine the location of the 'return' keyword when initializing the result of a function call.
TypeSourceInfo * getTypeSourceInfo() const
Retrieve complete type-source information for the object being constructed, if known.
ObjCMethodDecl * getMethodDecl() const
Retrieve the ObjectiveC method being initialized.
The injected class name of a C++ class template or class template partial specialization.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
An lvalue reference type, per C++11 [dcl.ref].
Describes the capture of a variable or of this, or of a C++1y init-capture.
bool capturesVariable() const
Determine whether this capture handles a variable.
Represents the results of name lookup.
bool empty() const
Return true if no decls were found.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represent a C++ namespace.
Represents a place-holder for an object not to be initialized by anything.
ObjCEncodeExpr, used for @encode in Objective-C.
QualType getEncodedType() const
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
bool isAvailableOption(llvm::StringRef Ext, const LangOptions &LO) const
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
void clear(CandidateSetKind CSK)
Clear out all of the candidates.
void setDestAS(LangAS AS)
@ CSK_InitByConstructor
C++ [over.match.ctor], [over.match.list] Initialization of an object of class type by constructor,...
@ CSK_InitByUserDefinedConversion
C++ [over.match.copy]: Copy-initialization of an object of class type by user-defined conversion.
@ CSK_Normal
Normal lookup.
SmallVectorImpl< OverloadCandidate >::iterator iterator
void NoteCandidates(PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
SmallVector< OverloadCandidate *, 32 > CompleteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, SourceLocation OpLoc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
Represents a parameter to a function.
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
QualType withConst() const
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool isConstQualified() const
Determine whether this type is const-qualified.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
The collection of all-type qualifiers we support.
unsigned getCVRQualifiers() const
void addAddressSpace(LangAS space)
@ OCL_Weak
Reading or writing from this object requires a barrier call.
bool hasQualifiers() const
Return true if the set contains any qualifiers.
bool hasAddressSpace() const
Qualifiers withoutAddressSpace() const
void removeAddressSpace()
static Qualifiers fromCVRMask(unsigned CVR)
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B)
Returns true if address space A is equal to or a superset of B.
bool hasObjCLifetime() const
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
LangAS getAddressSpace() const
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
bool hasFlexibleArrayMember() const
field_iterator field_end() const
field_range fields() const
bool isRandomized() const
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
specific_decl_iterator< FieldDecl > field_iterator
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Base for LValueReferenceType and RValueReferenceType.
bool isSpelledAsLValue() const
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
bool CheckObjCBridgeRelatedConversions(SourceLocation Loc, QualType DestType, QualType SrcType, Expr *&SrcExpr, bool Diagnose=true)
bool isObjCWritebackConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
Determine whether this is an Objective-C writeback conversion, used for parameter passing when perfor...
bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr, bool Diagnose=true)
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type,...
void EmitRelatedResultTypeNoteForReturn(QualType destType)
Given that we had incompatible pointer types in a return statement, check whether we're in a method w...
Sema - This implements semantic analysis and AST building for C.
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
CXXSpecialMemberKind getSpecialMember(const CXXMethodDecl *MD)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
bool DiagRedefinedPlaceholderFieldDecl(SourceLocation Loc, RecordDecl *ClassDecl, const IdentifierInfo *Name)
ImplicitConversionSequence TryImplicitConversion(Expr *From, QualType ToType, bool SuppressUserConversions, AllowedExplicit AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion)
bool IsStringInit(Expr *Init, const ArrayType *AT)
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, QualType DeclInitType, MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl< Expr * > &ConvertedArgs, bool AllowExplicit=false, bool IsListInitialization=false)
Given a constructor and the set of arguments provided for the constructor, convert the arguments and ...
void AddConversionCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion=true)
AddConversionCandidate - Add a C++ conversion function as a candidate in the candidate set (C++ [over...
ReferenceCompareResult
ReferenceCompareResult - Expresses the result of comparing two types (cv1 T1 and cv2 T2) to determine...
@ Ref_Incompatible
Ref_Incompatible - The two types are incompatible, so direct reference binding is not possible.
@ Ref_Compatible
Ref_Compatible - The two types are reference-compatible.
@ Ref_Related
Ref_Related - The two types are reference-related, which means that their unqualified forms (T1 and T...
void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion=true)
Adds a conversion function template specialization candidate to the overload set, using template argu...
FunctionTemplateDecl * DeclareAggregateDeductionGuideFromInitList(TemplateDecl *Template, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc)
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor,...
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
ExprResult ActOnDesignatedInitializer(Designation &Desig, SourceLocation EqualOrColonLoc, bool GNUSyntax, ExprResult Init)
FPOptionsOverride CurFPFeatureOverrides()
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we're implicitly casting from a _Nullable pointer type to a _Nonnull one.
DiagnosticsEngine & getDiagnostics() const
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over....
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
ASTContext & getASTContext() const
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
bool isInitListConstructor(const FunctionDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init....
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, const SourceRange &, DeclAccessPair FoundDecl)
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
llvm::SmallVector< QualType, 4 > CurrentParameterCopyTypes
Stack of types that correspond to the parameter entities that are currently being copy-initialized.
std::string getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const
Get a string to suggest for zero-initialization of a type.
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
CXXConstructorDecl * LookupDefaultConstructor(CXXRecordDecl *Class)
Look up the default constructor for the given class.
const LangOptions & getLangOpts() const
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
ExprResult PerformQualificationConversion(Expr *E, QualType Ty, ExprValueKind VK=VK_PRValue, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl)
Wrap the expression in a ConstantExpr if it is a potential immediate invocation.
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitDefaultConstructor - Checks for feasibility of defining this constructor as the default...
SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL, unsigned ByteNo) const
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
bool isInLifetimeExtendingContext() const
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, DeclAccessPair FoundDecl, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp=false)
Checks access to a constructor.
AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair FoundDecl)
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ Compatible
Compatible - the types are compatible according to the standard.
@ Incompatible
Incompatible - We reject this conversion outright, it is invalid to represent it in the AST.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, CXXConstructionKind ConstructKind, SourceRange ParenRange)
BuildCXXConstructExpr - Creates a complete call to a constructor, including handling of its default a...
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
ExprResult FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
void DiscardMisalignedMemberAddress(const Type *T, Expr *E)
This function checks if the expression is in the sef of potentially misaligned members and it is conv...
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed.
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=std::nullopt, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
bool CanPerformAggregateInitializationForOverloadResolution(const InitializedEntity &Entity, InitListExpr *From)
Determine whether we can perform aggregate initialization for the purposes of overload resolution.
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL,...
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, ReferenceConversions *Conv=nullptr)
CompareReferenceRelationship - Compare the two types T1 and T2 to determine whether they are referenc...
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the initializer (and its subobjects) is sufficient for initializing the en...
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
QualType getCompletedType(Expr *E)
Get the type of expression E, triggering instantiation to complete the type if necessary – that is,...
SourceManager & SourceMgr
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
static bool CanBeGetReturnObject(const FunctionDecl *FD)
NamespaceDecl * getStdNamespace() const
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
QualType SubstAutoTypeDependent(QualType TypeWithAuto)
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
bool CanPerformCopyInitialization(const InitializedEntity &Entity, ExprResult Init)
bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types.
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
CXXConstructorDecl * findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor, ConstructorUsingShadowDecl *DerivedShadow)
Given a derived-class using shadow declaration for a constructor and the correspnding base class cons...
ValueDecl * tryLookupUnambiguousFieldDecl(RecordDecl *ClassDecl, const IdentifierInfo *MemberOrBase)
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
bool isAtStartOfImmediateMacroExpansion(SourceLocation Loc, SourceLocation *MacroBegin=nullptr) const
Returns true if the given MacroID location points at the beginning of the immediate macro expansion.
A trivial tuple used to represent a source range.
void setBegin(SourceLocation b)
SourceLocation getEnd() const
SourceLocation getBegin() const
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3....
void setFromType(QualType T)
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion,...
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion,...
void setAsIdentityConversion()
StandardConversionSequence - Set the standard conversion sequence to the identity conversion.
void setToType(unsigned Idx, QualType T)
NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted, APValue &ConstantValue, QualType &ConstantType, bool IgnoreFloatToIntegralConversion=false) const
Check if this standard conversion sequence represents a narrowing conversion, according to C++11 [dcl...
void setAllToTypes(QualType T)
QualType getToType(unsigned Idx) const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
unsigned getLength() const
StringLiteralKind getKind() const
int64_t getCodeUnitS(size_t I, uint64_t BitWidth) const
StringRef getString() const
The base class of all kinds of template declarations (e.g., class, function, etc.).
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
bool isDependent() const
Determines whether this is a dependent template name.
Represents a type template specialization; the template must be a class template, a type alias templa...
const Type * getTypeForDecl() const
Base wrapper for a particular "section" of type source info.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceLocation getEndLoc() const
Get the end source location.
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBooleanType() const
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
bool isIncompleteArrayType() const
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isRValueReferenceType() const
bool isConstantArrayType() const
bool isPointerType() const
bool isArrayParameterType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isScalarType() const
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to.
bool isSizelessBuiltinType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isExtVectorType() const
bool isOCLIntelSubgroupAVCType() const
bool isLValueReferenceType() const
bool isOpenCLSpecificType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
bool isAnyComplexType() const
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isAtomicType() const
bool isFunctionProtoType() const
bool isObjCObjectType() const
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isVectorType() const
bool isFloatingType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isNullPtrType() const
bool isRecordType() const
bool isObjCRetainableType() const
Simple class containing the result of Sema::CorrectTypo.
DeclClass * getCorrectionDeclAs() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Represents a variable declaration or definition.
const Expr * getInit() const
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Represents a C array with a specified size that is not an integer-constant-expression.
Represents a GCC generic vector type.
unsigned getNumElements() const
VectorKind getVectorKind() const
QualType getElementType() const
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
bool Zero(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
OverloadingResult
OverloadingResult - Capture the result of performing overload resolution.
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
@ OR_Ambiguous
Ambiguous candidates found.
@ OR_No_Viable_Function
No viable function found.
bool isCompoundAssignmentOperator(OverloadedOperatorKind Kind)
Determine if this is a compound assignment operator.
@ ovl_fail_bad_conversion
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
LLVM_READONLY bool isUppercase(unsigned char c)
Return true if this character is an uppercase ASCII letter: [A-Z].
@ LCK_ByRef
Capturing by reference.
@ SD_Automatic
Automatic storage duration (most local variables).
@ Result
The result type of a method or function.
@ ICK_Integral_Conversion
Integral conversions (C++ [conv.integral])
@ ICK_Floating_Integral
Floating-integral conversions (C++ [conv.fpint])
@ ICK_Array_To_Pointer
Array-to-pointer conversion (C++ [conv.array])
@ ICK_Lvalue_To_Rvalue
Lvalue-to-rvalue conversion (C++ [conv.lval])
@ ICK_Writeback_Conversion
Objective-C ARC writeback conversion.
ActionResult< Expr * > ExprResult
CastKind
CastKind - The kind of operation required for a conversion.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
Expr * IgnoreParensSingleStep(Expr *E)
const FunctionProtoType * T
@ NK_Not_Narrowing
Not a narrowing conversion.
@ NK_Constant_Narrowing
A narrowing conversion, because a constant expression got narrowed.
@ NK_Dependent_Narrowing
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
@ NK_Type_Narrowing
A narrowing conversion by virtue of the source and destination types.
@ NK_Variable_Narrowing
A narrowing conversion, because a non-constant-expression variable might have got narrowed.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
ConstructorInfo getConstructorInfo(NamedDecl *ND)
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Braces
New-expression has a C++11 list-initializer.
CheckedConversionKind
The kind of conversion being performed.
@ Implicit
An implicit conversion.
@ CStyleCast
A C-style cast.
@ OtherCast
A cast other than a C-style cast.
@ FunctionalCast
A functional-style cast.
MutableArrayRef< Expr * > MultiExprArg
CXXConstructorDecl * Constructor
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
bool HadMultipleCandidates
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
bool Viable
Viable - True to indicate that this overload candidate is viable.
unsigned char FailureKind
FailureKind - The reason why this candidate is not viable.
ConversionSequenceList Conversions
The conversion sequences used to convert the function arguments to the function parameters.
ReferenceConversions
The conversions that would be performed on an lvalue of type T2 when binding a reference of type T1 t...
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion.