33#include "llvm/ADT/APInt.h" 
   34#include "llvm/ADT/FoldingSet.h" 
   35#include "llvm/ADT/PointerIntPair.h" 
   36#include "llvm/ADT/SmallVector.h" 
   37#include "llvm/ADT/StringExtras.h" 
   38#include "llvm/Support/ErrorHandling.h" 
   39#include "llvm/Support/raw_ostream.h" 
   50  if (Context.typesAreCompatible(Context.getWideCharType(), 
T))
 
   52  if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) {
 
   53    return Context.typesAreCompatible(Context.Char16Ty, 
T) ||
 
   54           Context.typesAreCompatible(Context.Char32Ty, 
T);
 
 
   93  auto IsCharOrUnsignedChar = [](
const QualType &
T) {
 
   94    const BuiltinType *BT = dyn_cast<BuiltinType>(
T.getTypePtr());
 
  105        (Context.getLangOpts().Char8 &&
 
  115              Context.getLangOpts().Char8)
 
  129    if (Context.typesAreCompatible(Context.Char16Ty, ElemTy))
 
  137    if (Context.typesAreCompatible(Context.Char32Ty, ElemTy))
 
  145    if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy))
 
  153    assert(
false && 
"Unevaluated string literal in initialization");
 
  157  llvm_unreachable(
"missed a StringLiteral kind?");
 
 
  204  if (
const auto *VD = dyn_cast_if_present<VarDecl>(D); VD && VD->isConstexpr())
 
 
  215                            bool CheckC23ConstexprInit = 
false) {
 
  217  auto *ConstantArrayTy =
 
  219  uint64_t StrLength = ConstantArrayTy->getZExtSize();
 
  221  if (CheckC23ConstexprInit)
 
  228    llvm::APInt ConstVal(32, StrLength);
 
  253    if (StrLength > ArrayLen)
 
  255             diag::err_initializer_string_for_char_array_too_long)
 
  259    if (StrLength - 1 > ArrayLen)
 
  261             diag::ext_initializer_string_for_char_array_too_long)
 
  263    else if (StrLength - 1 == ArrayLen) {
 
  266      const auto *SL = dyn_cast<StringLiteral>(Str->
IgnoreParens());
 
  267      bool IsSLSafe = SL && SL->getLength() > 0 &&
 
  268                      SL->getCodeUnit(SL->getLength() - 1) == 0;
 
  275        auto FindCorrectEntity =
 
  287        if (
const ValueDecl *D = FindCorrectEntity(&Entity);
 
  288            !D || !D->
hasAttr<NonStringAttr>())
 
  292                  warn_initializer_string_for_char_array_too_long_no_nonstring)
 
  297             diag::warn_initializer_string_for_char_array_too_long_for_cpp)
 
 
  311    if (Field->hasAttr<ExplicitInitAttr>())
 
  312      S.
Diag(Field->getLocation(), diag::note_entity_declared_at) << Field;
 
 
  353class InitListChecker {
 
  355  bool hadError = 
false;
 
  357  bool TreatUnavailableAsInvalid; 
 
  358  bool InOverloadResolution;
 
  359  InitListExpr *FullyStructuredList = 
nullptr;
 
  360  NoInitExpr *DummyExpr = 
nullptr;
 
  361  SmallVectorImpl<QualType> *AggrDeductionCandidateParamTypes = 
nullptr;
 
  362  EmbedExpr *CurEmbed = 
nullptr; 
 
  363  unsigned CurEmbedIndex = 0;
 
  365  NoInitExpr *getDummyInit() {
 
  371  void CheckImplicitInitList(
const InitializedEntity &Entity,
 
  372                             InitListExpr *ParentIList, QualType 
T,
 
  373                             unsigned &Index, InitListExpr *StructuredList,
 
  374                             unsigned &StructuredIndex);
 
  375  void CheckExplicitInitList(
const InitializedEntity &Entity,
 
  376                             InitListExpr *IList, QualType &
T,
 
  377                             InitListExpr *StructuredList,
 
  378                             bool TopLevelObject = 
false);
 
  379  void CheckListElementTypes(
const InitializedEntity &Entity,
 
  380                             InitListExpr *IList, QualType &DeclType,
 
  381                             bool SubobjectIsDesignatorContext,
 
  383                             InitListExpr *StructuredList,
 
  384                             unsigned &StructuredIndex,
 
  385                             bool TopLevelObject = 
false);
 
  386  void CheckSubElementType(
const InitializedEntity &Entity,
 
  387                           InitListExpr *IList, QualType ElemType,
 
  389                           InitListExpr *StructuredList,
 
  390                           unsigned &StructuredIndex,
 
  391                           bool DirectlyDesignated = 
false);
 
  392  void CheckComplexType(
const InitializedEntity &Entity,
 
  393                        InitListExpr *IList, QualType DeclType,
 
  395                        InitListExpr *StructuredList,
 
  396                        unsigned &StructuredIndex);
 
  397  void CheckScalarType(
const InitializedEntity &Entity,
 
  398                       InitListExpr *IList, QualType DeclType,
 
  400                       InitListExpr *StructuredList,
 
  401                       unsigned &StructuredIndex);
 
  402  void CheckReferenceType(
const InitializedEntity &Entity,
 
  403                          InitListExpr *IList, QualType DeclType,
 
  405                          InitListExpr *StructuredList,
 
  406                          unsigned &StructuredIndex);
 
  407  void CheckMatrixType(
const InitializedEntity &Entity, InitListExpr *IList,
 
  408                       QualType DeclType, 
unsigned &Index,
 
  409                       InitListExpr *StructuredList, 
unsigned &StructuredIndex);
 
  410  void CheckVectorType(
const InitializedEntity &Entity,
 
  411                       InitListExpr *IList, QualType DeclType, 
unsigned &Index,
 
  412                       InitListExpr *StructuredList,
 
  413                       unsigned &StructuredIndex);
 
  414  void CheckStructUnionTypes(
const InitializedEntity &Entity,
 
  415                             InitListExpr *IList, QualType DeclType,
 
  418                             bool SubobjectIsDesignatorContext, 
unsigned &Index,
 
  419                             InitListExpr *StructuredList,
 
  420                             unsigned &StructuredIndex,
 
  421                             bool TopLevelObject = 
false);
 
  422  void CheckArrayType(
const InitializedEntity &Entity,
 
  423                      InitListExpr *IList, QualType &DeclType,
 
  424                      llvm::APSInt elementIndex,
 
  425                      bool SubobjectIsDesignatorContext, 
unsigned &Index,
 
  426                      InitListExpr *StructuredList,
 
  427                      unsigned &StructuredIndex);
 
  428  bool CheckDesignatedInitializer(
const InitializedEntity &Entity,
 
  429                                  InitListExpr *IList, DesignatedInitExpr *DIE,
 
  431                                  QualType &CurrentObjectType,
 
  433                                  llvm::APSInt *NextElementIndex,
 
  435                                  InitListExpr *StructuredList,
 
  436                                  unsigned &StructuredIndex,
 
  437                                  bool FinishSubobjectInit,
 
  438                                  bool TopLevelObject);
 
  439  InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, 
unsigned Index,
 
  440                                           QualType CurrentObjectType,
 
  441                                           InitListExpr *StructuredList,
 
  442                                           unsigned StructuredIndex,
 
  443                                           SourceRange InitRange,
 
  444                                           bool IsFullyOverwritten = 
false);
 
  445  void UpdateStructuredListElement(InitListExpr *StructuredList,
 
  446                                   unsigned &StructuredIndex,
 
  448  InitListExpr *createInitListExpr(QualType CurrentObjectType,
 
  449                                   SourceRange InitRange,
 
  450                                   unsigned ExpectedNumInits);
 
  451  int numArrayElements(QualType DeclType);
 
  452  int numStructUnionElements(QualType DeclType);
 
  454  ExprResult PerformEmptyInit(SourceLocation Loc,
 
  455                              const InitializedEntity &Entity);
 
  458  void diagnoseInitOverride(Expr *OldInit, SourceRange NewInitRange,
 
  459                            bool UnionOverride = 
false,
 
  460                            bool FullyOverwritten = 
true) {
 
  465            ? (UnionOverride ? diag::ext_initializer_union_overrides
 
  466                             : diag::ext_initializer_overrides)
 
  467            : diag::warn_initializer_overrides;
 
  469    if (InOverloadResolution && SemaRef.
getLangOpts().CPlusPlus) {
 
  490      DiagID = diag::err_initializer_overrides_destructed;
 
  510          << NewInitRange << FullyOverwritten << OldInit->
getType();
 
  536  void FillInEmptyInitForBase(
unsigned Init, 
const CXXBaseSpecifier &Base,
 
  537                              const InitializedEntity &ParentEntity,
 
  538                              InitListExpr *ILE, 
bool &RequiresSecondPass,
 
  539                              bool FillWithNoInit);
 
  540  void FillInEmptyInitForField(
unsigned Init, FieldDecl *Field,
 
  541                               const InitializedEntity &ParentEntity,
 
  542                               InitListExpr *ILE, 
bool &RequiresSecondPass,
 
  543                               bool FillWithNoInit = 
false);
 
  544  void FillInEmptyInitializations(
const InitializedEntity &Entity,
 
  545                                  InitListExpr *ILE, 
bool &RequiresSecondPass,
 
  546                                  InitListExpr *OuterILE, 
unsigned OuterIndex,
 
  547                                  bool FillWithNoInit = 
false);
 
  548  bool CheckFlexibleArrayInit(
const InitializedEntity &Entity,
 
  549                              Expr *InitExpr, FieldDecl *Field,
 
  550                              bool TopLevelObject);
 
  551  void CheckEmptyInitializable(
const InitializedEntity &Entity,
 
  554  Expr *HandleEmbed(EmbedExpr *Embed, 
const InitializedEntity &Entity) {
 
  568      assert(AType && 
"expected array type when initializing array");
 
  570      if (
const auto *CAType = dyn_cast<ConstantArrayType>(AType))
 
  571        ElsCount = std::min(CAType->getSize().getZExtValue() - ArrIndex,
 
  572                            ElsCount - CurEmbedIndex);
 
  582                  CurEmbedIndex, ElsCount);
 
  583    CurEmbedIndex += ElsCount;
 
  593      Sema &S, 
const InitializedEntity &Entity, InitListExpr *IL, QualType &
T,
 
  594      bool VerifyOnly, 
bool TreatUnavailableAsInvalid,
 
  595      bool InOverloadResolution = 
false,
 
  596      SmallVectorImpl<QualType> *AggrDeductionCandidateParamTypes = 
nullptr);
 
  597  InitListChecker(Sema &S, 
const InitializedEntity &Entity, InitListExpr *IL,
 
  599                  SmallVectorImpl<QualType> &AggrDeductionCandidateParamTypes)
 
  600      : InitListChecker(S, Entity, IL, 
T, 
true,
 
  603                        &AggrDeductionCandidateParamTypes) {}
 
  605  bool HadError() { 
return hadError; }
 
  609  InitListExpr *getFullyStructuredList()
 const { 
return FullyStructuredList; }
 
  626  bool EmptyInitList = SemaRef.
getLangOpts().CPlusPlus11 &&
 
  639    InitExpr = VerifyOnly ? &DummyInitList
 
  656  if (!InitSeq && EmptyInitList &&
 
  657      InitSeq.getFailureKind() ==
 
  662        InitSeq.getFailedCandidateSet()
 
  663            .BestViableFunction(SemaRef, 
Kind.getLocation(), Best);
 
  665    assert(O == 
OR_Success && 
"Inconsistent overload resolution");
 
  672      bool IsInStd = 
false;
 
  674           ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
 
  680          llvm::StringSwitch<bool>(R->
getName())
 
  681              .Cases({
"basic_string", 
"deque", 
"forward_list"}, 
true)
 
  682              .Cases({
"list", 
"map", 
"multimap", 
"multiset"}, 
true)
 
  683              .Cases({
"priority_queue", 
"queue", 
"set", 
"stack"}, 
true)
 
  684              .Cases({
"unordered_map", 
"unordered_set", 
"vector"}, 
true)
 
  686        InitSeq.InitializeFrom(
 
  690            TreatUnavailableAsInvalid);
 
  695                       diag::warn_invalid_initializer_from_system_header);
 
  698                         diag::note_used_in_initialization_here);
 
  700            SemaRef.
Diag(Loc, diag::note_used_in_initialization_here);
 
  707      InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
 
  710                     diag::note_in_omitted_aggregate_initializer)
 
  713        bool IsTrailingArrayNewMember =
 
  716        SemaRef.
Diag(Loc, diag::note_in_omitted_aggregate_initializer)
 
  717          << (IsTrailingArrayNewMember ? 2 : 0)
 
  726                    : InitSeq.Perform(SemaRef, Entity, 
Kind, SubInit);
 
  734  if (FullyStructuredList)
 
  736  PerformEmptyInit(Loc, Entity);
 
  739void InitListChecker::FillInEmptyInitForBase(
 
  742    bool &RequiresSecondPass, 
bool FillWithNoInit) {
 
  744      SemaRef.
Context, &Base, 
false, &ParentEntity);
 
  749                              : PerformEmptyInit(ILE->
getEndLoc(), BaseEntity);
 
  756      assert(
Init < ILE->getNumInits() && 
"should have been expanded");
 
  761    FillInEmptyInitializations(BaseEntity, InnerILE, RequiresSecondPass,
 
  762                               ILE, 
Init, FillWithNoInit);
 
  764               dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(
Init))) {
 
  765    FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),
 
  766                               RequiresSecondPass, ILE, 
Init,
 
  771void InitListChecker::FillInEmptyInitForField(
unsigned Init, 
FieldDecl *Field,
 
  774                                              bool &RequiresSecondPass,
 
  775                                              bool FillWithNoInit) {
 
  783      if (!RType->getDecl()->isUnion())
 
  784        assert((
Init < NumInits || VerifyOnly) &&
 
  785               "This ILE should have been expanded");
 
  787    if (FillWithNoInit) {
 
  788      assert(!VerifyOnly && 
"should not fill with no-init in verify-only mode");
 
  797    if (!VerifyOnly && 
Field->hasAttr<ExplicitInitAttr>() &&
 
  799      SemaRef.
Diag(ILE->
getExprLoc(), diag::warn_field_requires_explicit_init)
 
  801      SemaRef.
Diag(
Field->getLocation(), diag::note_entity_declared_at)
 
  809    if (
Field->hasInClassInitializer()) {
 
  839        RequiresSecondPass = 
true;
 
  844    if (
Field->getType()->isReferenceType()) {
 
  850        SemaRef.
Diag(Loc, diag::err_init_reference_member_uninitialized)
 
  854        SemaRef.
Diag(
Field->getLocation(), diag::note_uninit_reference_member);
 
  860    ExprResult MemberInit = PerformEmptyInit(Loc, MemberEntity);
 
  866    if (hadError || VerifyOnly) {
 
  868    } 
else if (
Init < NumInits) {
 
  876      RequiresSecondPass = 
true;
 
  880    FillInEmptyInitializations(MemberEntity, InnerILE,
 
  881                               RequiresSecondPass, ILE, 
Init, FillWithNoInit);
 
  883                 dyn_cast<DesignatedInitUpdateExpr>(ILE->
getInit(
Init))) {
 
  884    FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
 
  885                               RequiresSecondPass, ILE, 
Init,
 
  896                                            bool &RequiresSecondPass,
 
  899                                            bool FillWithNoInit) {
 
  901         "Should not have void type");
 
  905  if (FillWithNoInit && VerifyOnly)
 
  915  struct UpdateOuterILEWithUpdatedInit {
 
  918    ~UpdateOuterILEWithUpdatedInit() {
 
  922  } UpdateOuterRAII = {OuterILE, OuterIndex};
 
  932                              RequiresSecondPass, FillWithNoInit);
 
  936             "We should have computed initialized fields already");
 
  940      unsigned NumElems = numStructUnionElements(ILE->
getType());
 
  941      if (!RDecl->isUnion() && RDecl->hasFlexibleArrayMember())
 
  948      if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {
 
  949        for (
auto &Base : CXXRD->bases()) {
 
  953          FillInEmptyInitForBase(
Init, Base, Entity, ILE, RequiresSecondPass,
 
  959      for (
auto *Field : RDecl->fields()) {
 
  960        if (
Field->isUnnamedBitField())
 
  966        FillInEmptyInitForField(
Init, Field, Entity, ILE, RequiresSecondPass,
 
  974        if (RDecl->isUnion())
 
  988    ElementType = AType->getElementType();
 
  989    if (
const auto *CAType = dyn_cast<ConstantArrayType>(AType))
 
  990      NumElements = CAType->getZExtSize();
 
  998    ElementType = VType->getElementType();
 
  999    NumElements = VType->getNumElements();
 
 1005  bool SkipEmptyInitChecks = 
false;
 
 1024      if (SkipEmptyInitChecks)
 
 1027      Expr *Filler = 
nullptr;
 
 1033            PerformEmptyInit(ILE->
getEndLoc(), ElementEntity);
 
 1044      } 
else if (VerifyOnly) {
 
 1045        SkipEmptyInitChecks = 
true;
 
 1046      } 
else if (
Init < NumInits) {
 
 1067          RequiresSecondPass = 
true;
 
 1071                 = dyn_cast_or_null<InitListExpr>(InitExpr)) {
 
 1072      FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
 
 1073                                 ILE, 
Init, FillWithNoInit);
 
 1075                   dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr)) {
 
 1076      FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
 
 1077                                 RequiresSecondPass, ILE, 
Init,
 
 1085    if (isa_and_nonnull<DesignatedInitExpr>(
Init))
 
 
 1090InitListChecker::InitListChecker(
 
 1092    bool VerifyOnly, 
bool TreatUnavailableAsInvalid, 
bool InOverloadResolution,
 
 1094    : SemaRef(S), VerifyOnly(VerifyOnly),
 
 1095      TreatUnavailableAsInvalid(TreatUnavailableAsInvalid),
 
 1096      InOverloadResolution(InOverloadResolution),
 
 1097      AggrDeductionCandidateParamTypes(AggrDeductionCandidateParamTypes) {
 
 1099    FullyStructuredList =
 
 1108  CheckExplicitInitList(Entity, IL, 
T, FullyStructuredList,
 
 1111  if (!hadError && !AggrDeductionCandidateParamTypes && FullyStructuredList) {
 
 1112    bool RequiresSecondPass = 
false;
 
 1113    FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass,
 
 1115    if (RequiresSecondPass && !hadError)
 
 1116      FillInEmptyInitializations(Entity, FullyStructuredList,
 
 1117                                 RequiresSecondPass, 
nullptr, 0);
 
 1119  if (hadError && FullyStructuredList)
 
 1123int InitListChecker::numArrayElements(
QualType DeclType) {
 
 1125  int maxElements = 0x7FFFFFFF;
 
 1126  if (
const ConstantArrayType *CAT =
 
 1128    maxElements = 
static_cast<int>(CAT->getZExtSize());
 
 1133int InitListChecker::numStructUnionElements(QualType DeclType) {
 
 1135  int InitializableMembers = 0;
 
 1136  if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl))
 
 1137    InitializableMembers += CXXRD->getNumBases();
 
 1138  for (
const auto *Field : structDecl->fields())
 
 1139    if (!
Field->isUnnamedBitField())
 
 1140      ++InitializableMembers;
 
 1142  if (structDecl->isUnion())
 
 1143    return std::min(InitializableMembers, 1);
 
 1144  return InitializableMembers - structDecl->hasFlexibleArrayMember();
 
 1171    if (
CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(ParentRD)) {
 
 1172      if (CXXRD->getNumBases()) {
 
 1177    assert(FieldIt != ParentRD->field_end() &&
 
 1178           "no fields but have initializer for member?");
 
 1179    return ++FieldIt == ParentRD->field_end();
 
 
 1191void InitListChecker::CheckImplicitInitList(
const InitializedEntity &Entity,
 
 1192                                            InitListExpr *ParentIList,
 
 1193                                            QualType 
T, 
unsigned &Index,
 
 1194                                            InitListExpr *StructuredList,
 
 1195                                            unsigned &StructuredIndex) {
 
 1196  int maxElements = 0;
 
 1199    maxElements = numArrayElements(
T);
 
 1201    maxElements = numStructUnionElements(
T);
 
 1203    maxElements = 
T->
castAs<VectorType>()->getNumElements();
 
 1205    llvm_unreachable(
"CheckImplicitInitList(): Illegal type");
 
 1207  if (maxElements == 0) {
 
 1210                   diag::err_implicit_empty_initializer);
 
 1217  InitListExpr *StructuredSubobjectInitList = getStructuredSubobjectInit(
 
 1218      ParentIList, Index, 
T, StructuredList, StructuredIndex,
 
 1221  unsigned StructuredSubobjectInitIndex = 0;
 
 1224  unsigned StartIndex = Index;
 
 1225  CheckListElementTypes(Entity, ParentIList, 
T,
 
 1227                        StructuredSubobjectInitList,
 
 1228                        StructuredSubobjectInitIndex);
 
 1230  if (StructuredSubobjectInitList) {
 
 1231    StructuredSubobjectInitList->
setType(
T);
 
 1233    unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
 
 1236    if (EndIndex < ParentIList->getNumInits() &&
 
 1237        ParentIList->
getInit(EndIndex)) {
 
 1238      SourceLocation EndLoc
 
 1248                   diag::warn_missing_braces)
 
 1254                     StructuredSubobjectInitList->
getEndLoc()),
 
 1260    if (!VerifyOnly && CXXRD && CXXRD->hasUserDeclaredConstructor()) {
 
 1262                   diag::warn_cxx20_compat_aggregate_init_with_ctors)
 
 1278  unsigned DiagID = 0;
 
 1291    DiagID = diag::warn_braces_around_init;
 
 1298      DiagID = diag::warn_braces_around_init;
 
 1324    llvm_unreachable(
"unexpected braced scalar init");
 
 
 1340void InitListChecker::CheckExplicitInitList(
const InitializedEntity &Entity,
 
 1341                                            InitListExpr *IList, QualType &
T,
 
 1342                                            InitListExpr *StructuredList,
 
 1343                                            bool TopLevelObject) {
 
 1344  unsigned Index = 0, StructuredIndex = 0;
 
 1345  CheckListElementTypes(Entity, IList, 
T, 
true,
 
 1346                        Index, StructuredList, StructuredIndex, TopLevelObject);
 
 1347  if (StructuredList) {
 
 1348    QualType ExprTy = 
T;
 
 1353    StructuredList->
setType(ExprTy);
 
 1361    bool ExtraInitsIsError = SemaRef.
getLangOpts().CPlusPlus ||
 
 1363    hadError = ExtraInitsIsError;
 
 1366    } 
else if (StructuredIndex == 1 &&
 
 1371              ? diag::err_excess_initializers_in_char_array_initializer
 
 1372              : diag::ext_excess_initializers_in_char_array_initializer;
 
 1376      unsigned DK = ExtraInitsIsError
 
 1377                        ? diag::err_excess_initializers_for_sizeless_type
 
 1378                        : diag::ext_excess_initializers_for_sizeless_type;
 
 1389      unsigned DK = ExtraInitsIsError ? diag::err_excess_initializers
 
 1390                                      : diag::ext_excess_initializers;
 
 1404    if (CXXRD && CXXRD->hasUserDeclaredConstructor()) {
 
 1407      bool HasEquivCtor = 
false;
 
 1410        HasEquivCtor = CD && !CD->isDeleted();
 
 1413      if (!HasEquivCtor) {
 
 1415                     diag::warn_cxx20_compat_aggregate_init_with_ctors)
 
 1422void InitListChecker::CheckListElementTypes(
const InitializedEntity &Entity,
 
 1423                                            InitListExpr *IList,
 
 1425                                            bool SubobjectIsDesignatorContext,
 
 1427                                            InitListExpr *StructuredList,
 
 1428                                            unsigned &StructuredIndex,
 
 1429                                            bool TopLevelObject) {
 
 1433    CheckComplexType(Entity, IList, DeclType, Index,
 
 1434                     StructuredList, StructuredIndex);
 
 1436    CheckScalarType(Entity, IList, DeclType, Index,
 
 1437                    StructuredList, StructuredIndex);
 
 1439    CheckVectorType(Entity, IList, DeclType, Index,
 
 1440                    StructuredList, StructuredIndex);
 
 1442    CheckMatrixType(Entity, IList, DeclType, Index, StructuredList,
 
 1450             "non-aggregate records should be handed in CheckSubElementType");
 
 1451      if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
 
 1452        Bases = CXXRD->bases();
 
 1456    CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(),
 
 1457                          SubobjectIsDesignatorContext, Index, StructuredList,
 
 1458                          StructuredIndex, TopLevelObject);
 
 1463    CheckArrayType(Entity, IList, DeclType, 
Zero,
 
 1464                   SubobjectIsDesignatorContext, Index,
 
 1465                   StructuredList, StructuredIndex);
 
 1470      SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
 
 1474    CheckReferenceType(Entity, IList, DeclType, Index,
 
 1475                       StructuredList, StructuredIndex);
 
 1478      SemaRef.
Diag(IList->
getBeginLoc(), diag::err_init_objc_class) << DeclType;
 
 1483    CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
 
 1490    assert(AggrDeductionCandidateParamTypes);
 
 1491    AggrDeductionCandidateParamTypes->push_back(DeclType);
 
 1494      SemaRef.
Diag(IList->
getBeginLoc(), diag::err_illegal_initializer_type)
 
 1500void InitListChecker::CheckSubElementType(
const InitializedEntity &Entity,
 
 1501                                          InitListExpr *IList,
 
 1504                                          InitListExpr *StructuredList,
 
 1505                                          unsigned &StructuredIndex,
 
 1506                                          bool DirectlyDesignated) {
 
 1510    return CheckReferenceType(Entity, IList, ElemType, Index,
 
 1511                              StructuredList, StructuredIndex);
 
 1513  if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(
expr)) {
 
 1514    if (SubInitList->getNumInits() == 1 &&
 
 1519      expr = SubInitList->getInit(0);
 
 1526           "found implicit initialization for the wrong type");
 
 1527    UpdateStructuredListElement(StructuredList, StructuredIndex, 
expr);
 
 1538    InitializationKind 
Kind =
 
 1549    if (TmpEntity.getType()->isDependentType()) {
 
 1554      assert(AggrDeductionCandidateParamTypes);
 
 1569          !isa_and_present<ConstantArrayType>(
 
 1572        AggrDeductionCandidateParamTypes->push_back(ElemType);
 
 1576      InitializationSequence 
Seq(SemaRef, TmpEntity, Kind, 
expr,
 
 1585        if (
auto *Embed = dyn_cast<EmbedExpr>(
expr)) {
 
 1586          expr = HandleEmbed(Embed, Entity);
 
 1593          UpdateStructuredListElement(StructuredList, StructuredIndex,
 
 1597        } 
else if (StructuredList) {
 
 1598          UpdateStructuredListElement(StructuredList, StructuredIndex,
 
 1603        if (AggrDeductionCandidateParamTypes)
 
 1604          AggrDeductionCandidateParamTypes->push_back(ElemType);
 
 1612    return CheckScalarType(Entity, IList, ElemType, Index,
 
 1613                           StructuredList, StructuredIndex);
 
 1627        UpdateStructuredListElement(StructuredList, StructuredIndex, 
expr);
 
 1650        AssignConvertType::Incompatible) {
 
 1658      UpdateStructuredListElement(StructuredList, StructuredIndex,
 
 1659                                  ExprRes.
getAs<Expr>());
 
 1676    CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
 
 1681    if (DirectlyDesignated && SemaRef.
getLangOpts().CPlusPlus && !hadError) {
 
 1682      if (InOverloadResolution)
 
 1686                     diag::ext_designated_init_brace_elision)
 
 1687            << 
expr->getSourceRange()
 
 1702      assert(
Copy.isInvalid() &&
 
 1703             "expected non-aggregate initialization to fail");
 
 1711void InitListChecker::CheckComplexType(
const InitializedEntity &Entity,
 
 1712                                       InitListExpr *IList, QualType DeclType,
 
 1714                                       InitListExpr *StructuredList,
 
 1715                                       unsigned &StructuredIndex) {
 
 1716  assert(Index == 0 && 
"Index in explicit init list must be zero");
 
 1726    return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
 
 1731  if (!SemaRef.
getLangOpts().CPlusPlus && !VerifyOnly)
 
 1736  QualType elementType = DeclType->
castAs<ComplexType>()->getElementType();
 
 1737  InitializedEntity ElementEntity =
 
 1740  for (
unsigned i = 0; i < 2; ++i) {
 
 1742    CheckSubElementType(ElementEntity, IList, elementType, Index,
 
 1743                        StructuredList, StructuredIndex);
 
 1747void InitListChecker::CheckScalarType(
const InitializedEntity &Entity,
 
 1748                                      InitListExpr *IList, QualType DeclType,
 
 1750                                      InitListExpr *StructuredList,
 
 1751                                      unsigned &StructuredIndex) {
 
 1758                           ? diag::warn_cxx98_compat_empty_sizeless_initializer
 
 1759                           : diag::err_empty_sizeless_initializer)
 
 1764                           ? diag::warn_cxx98_compat_empty_scalar_initializer
 
 1765                           : diag::err_empty_scalar_initializer)
 
 1777  if (InitListExpr *SubIList = dyn_cast<InitListExpr>(
expr)) {
 
 1781      SemaRef.
Diag(SubIList->getBeginLoc(), diag::ext_many_braces_around_init)
 
 1784    CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
 
 1790                   diag::err_designator_for_scalar_or_sizeless_init)
 
 1792          << 
expr->getSourceRange();
 
 1797  } 
else if (
auto *Embed = dyn_cast<EmbedExpr>(
expr)) {
 
 1798    expr = HandleEmbed(Embed, Entity);
 
 1813  Expr *ResultExpr = 
nullptr;
 
 1818    ResultExpr = 
Result.getAs<Expr>();
 
 1820    if (ResultExpr != 
expr && !VerifyOnly && !CurEmbed) {
 
 1823      IList->
setInit(Index, ResultExpr);
 
 1827  UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
 
 1830  if (AggrDeductionCandidateParamTypes)
 
 1831    AggrDeductionCandidateParamTypes->push_back(DeclType);
 
 1834void InitListChecker::CheckReferenceType(
const InitializedEntity &Entity,
 
 1835                                         InitListExpr *IList, QualType DeclType,
 
 1837                                         InitListExpr *StructuredList,
 
 1838                                         unsigned &StructuredIndex) {
 
 1846                   diag::err_init_reference_member_uninitialized)
 
 1882  if (!VerifyOnly && 
expr)
 
 1885  UpdateStructuredListElement(StructuredList, StructuredIndex, 
expr);
 
 1887  if (AggrDeductionCandidateParamTypes)
 
 1888    AggrDeductionCandidateParamTypes->push_back(DeclType);
 
 1891void InitListChecker::CheckMatrixType(
const InitializedEntity &Entity,
 
 1892                                      InitListExpr *IList, QualType DeclType,
 
 1894                                      InitListExpr *StructuredList,
 
 1895                                      unsigned &StructuredIndex) {
 
 1899  const ConstantMatrixType *MT = DeclType->
castAs<ConstantMatrixType>();
 
 1903  unsigned NumEltsInit = 0;
 
 1904  InitializedEntity ElemEnt =
 
 1907  while (NumEltsInit < MaxElts && Index < IList->getNumInits()) {
 
 1910    CheckSubElementType(ElemEnt, IList, ElemTy, Index, StructuredList,
 
 1919  assert(NumEltsInit == MaxElts && 
"NumEltsInit must equal MaxElts");
 
 1922void InitListChecker::CheckVectorType(
const InitializedEntity &Entity,
 
 1923                                      InitListExpr *IList, QualType DeclType,
 
 1925                                      InitListExpr *StructuredList,
 
 1926                                      unsigned &StructuredIndex) {
 
 1927  const VectorType *VT = DeclType->
castAs<VectorType>();
 
 1929  unsigned numEltsInit = 0;
 
 1934    CheckEmptyInitializable(
 
 1957      Expr *ResultExpr = 
nullptr;
 
 1961        ResultExpr = 
Result.getAs<Expr>();
 
 1963        if (ResultExpr != 
Init && !VerifyOnly) {
 
 1966          IList->
setInit(Index, ResultExpr);
 
 1969      UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
 
 1971      if (AggrDeductionCandidateParamTypes)
 
 1972        AggrDeductionCandidateParamTypes->push_back(elementType);
 
 1976    InitializedEntity ElementEntity =
 
 1979    for (
unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
 
 1982        CheckEmptyInitializable(ElementEntity, IList->
getEndLoc());
 
 1987      CheckSubElementType(ElementEntity, IList, elementType, Index,
 
 1988                          StructuredList, StructuredIndex);
 
 1996    if (isBigEndian && (
T->getVectorKind() == VectorKind::Neon ||
 
 1997                        T->getVectorKind() == VectorKind::NeonPoly)) {
 
 2009                   diag::warn_neon_vector_initializer_non_portable);
 
 2011      const char *typeCode;
 
 2023        llvm_unreachable(
"Invalid element type!");
 
 2027                       ? diag::note_neon_vector_initializer_non_portable_q
 
 2028                       : diag::note_neon_vector_initializer_non_portable)
 
 2029          << typeCode << typeSize;
 
 2035  InitializedEntity ElementEntity =
 
 2039  for (
unsigned i = 0; i < maxElements; ++i) {
 
 2048      CheckSubElementType(ElementEntity, IList, elementType, Index,
 
 2049                          StructuredList, StructuredIndex);
 
 2053      const VectorType *IVT = IType->
castAs<VectorType>();
 
 2061      CheckSubElementType(ElementEntity, IList, VecType, Index,
 
 2062                          StructuredList, StructuredIndex);
 
 2063      numEltsInit += numIElts;
 
 2068  if (numEltsInit != maxElements) {
 
 2071                   diag::err_vector_incorrect_num_elements)
 
 2072          << (numEltsInit < maxElements) << maxElements << numEltsInit
 
 2099                                SemaRef.
PDiag(diag::err_access_dtor_temp)
 
 
 2119      ExprList.size() == 1
 
 2120          ? dyn_cast_if_present<EmbedExpr>(ExprList[0]->IgnoreParens())
 
 
 2133void InitListChecker::CheckArrayType(
const InitializedEntity &Entity,
 
 2134                                     InitListExpr *IList, QualType &DeclType,
 
 2135                                     llvm::APSInt elementIndex,
 
 2136                                     bool SubobjectIsDesignatorContext,
 
 2138                                     InitListExpr *StructuredList,
 
 2139                                     unsigned &StructuredIndex) {
 
 2157  if (Index < IList->getNumInits()) {
 
 2170      if (StructuredList) {
 
 2171        UpdateStructuredListElement(StructuredList, StructuredIndex,
 
 2176      if (AggrDeductionCandidateParamTypes)
 
 2177        AggrDeductionCandidateParamTypes->push_back(DeclType);
 
 2181  if (
const VariableArrayType *VAT = dyn_cast<VariableArrayType>(
arrayType)) {
 
 2198        SemaRef.
Diag(VAT->getSizeExpr()->getBeginLoc(),
 
 2199                     diag::err_variable_object_no_init)
 
 2200            << VAT->getSizeExpr()->getSourceRange();
 
 2209  llvm::APSInt maxElements(elementIndex.getBitWidth(),
 
 2210                           elementIndex.isUnsigned());
 
 2211  bool maxElementsKnown = 
false;
 
 2212  if (
const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(
arrayType)) {
 
 2213    maxElements = CAT->getSize();
 
 2214    elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
 
 2215    elementIndex.setIsUnsigned(maxElements.isUnsigned());
 
 2216    maxElementsKnown = 
true;
 
 2219  QualType elementType = 
arrayType->getElementType();
 
 2220  while (Index < IList->getNumInits()) {
 
 2222    if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(
Init)) {
 
 2226      if (!SubobjectIsDesignatorContext)
 
 2231      if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
 
 2232                                     DeclType, 
nullptr, &elementIndex, Index,
 
 2233                                     StructuredList, StructuredIndex, 
true,
 
 2239      if (elementIndex.getBitWidth() > maxElements.getBitWidth())
 
 2240        maxElements = maxElements.extend(elementIndex.getBitWidth());
 
 2241      else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
 
 2242        elementIndex = elementIndex.extend(maxElements.getBitWidth());
 
 2243      elementIndex.setIsUnsigned(maxElements.isUnsigned());
 
 2247      if (!maxElementsKnown && elementIndex > maxElements)
 
 2248        maxElements = elementIndex;
 
 2255    if (maxElementsKnown && elementIndex == maxElements)
 
 2259        SemaRef.
Context, StructuredIndex, Entity);
 
 2262    unsigned EmbedElementIndexBeforeInit = CurEmbedIndex;
 
 2264    CheckSubElementType(ElementEntity, IList, elementType, Index,
 
 2265                        StructuredList, StructuredIndex);
 
 2270            elementIndex + CurEmbedIndex - EmbedElementIndexBeforeInit - 1;
 
 2274                       EmbedElementIndexBeforeInit - 1;
 
 2280    if (!maxElementsKnown && elementIndex > maxElements)
 
 2281      maxElements = elementIndex;
 
 2286    llvm::APSInt 
Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
 
 2290      SemaRef.
Diag(IList->
getBeginLoc(), diag::ext_typecheck_zero_array_size);
 
 2294        elementType, maxElements, 
nullptr, ArraySizeModifier::Normal, 0);
 
 2301    if ((maxElementsKnown && elementIndex < maxElements) ||
 
 2303      CheckEmptyInitializable(
 
 2309bool InitListChecker::CheckFlexibleArrayInit(
const InitializedEntity &Entity,
 
 2312                                             bool TopLevelObject) {
 
 2314  unsigned FlexArrayDiag;
 
 2318    FlexArrayDiag = diag::ext_flexible_array_init;
 
 2319  } 
else if (!TopLevelObject) {
 
 2321    FlexArrayDiag = diag::err_flexible_array_init;
 
 2324    FlexArrayDiag = diag::err_flexible_array_init;
 
 2327    FlexArrayDiag = diag::err_flexible_array_init;
 
 2330    FlexArrayDiag = diag::ext_flexible_array_init;
 
 2336    SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
 
 2340  return FlexArrayDiag != diag::ext_flexible_array_init;
 
 2344  return StructuredList && StructuredList->
getNumInits() == 1U;
 
 
 2347void InitListChecker::CheckStructUnionTypes(
 
 2348    const InitializedEntity &Entity, InitListExpr *IList, QualType DeclType,
 
 2350    bool SubobjectIsDesignatorContext, 
unsigned &Index,
 
 2351    InitListExpr *StructuredList, 
unsigned &StructuredIndex,
 
 2352    bool TopLevelObject) {
 
 2366      for (FieldDecl *FD : RD->
fields()) {
 
 2377      if (!StructuredList)
 
 2380           Field != FieldEnd; ++Field) {
 
 2381        if (
Field->hasInClassInitializer() ||
 
 2382            (
Field->isAnonymousStructOrUnion() &&
 
 2384                 ->castAsCXXRecordDecl()
 
 2385                 ->hasInClassInitializer())) {
 
 2391      llvm_unreachable(
"Couldn't find in-class initializer");
 
 2397         Field != FieldEnd; ++Field) {
 
 2398      if (!
Field->isUnnamedBitField()) {
 
 2399        CheckEmptyInitializable(
 
 2410  bool InitializedSomething = 
false;
 
 2413  for (
auto I = Bases.begin(), E = Bases.end(); I != E; ++I) {
 
 2419    if (isa_and_nonnull<DesignatedInitExpr>(
Init))
 
 2436    if (AggrDeductionCandidateParamTypes && 
Base.isPackExpansion()) {
 
 2437      AggrDeductionCandidateParamTypes->push_back(
 
 2442        if (Index < IList->getNumInits())
 
 2452        SemaRef.
Context, &Base, 
false, &Entity);
 
 2454      CheckSubElementType(BaseEntity, IList, 
Base.getType(), Index,
 
 2455                          StructuredList, StructuredIndex);
 
 2456      InitializedSomething = 
true;
 
 2458      CheckEmptyInitializable(BaseEntity, InitLoc);
 
 2473  size_t NumRecordDecls = llvm::count_if(RD->
decls(), [&](
const Decl *D) {
 
 2474    return isa<FieldDecl>(D) || isa<RecordDecl>(D);
 
 2476  bool HasDesignatedInit = 
false;
 
 2478  llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
 
 2480  while (Index < IList->getNumInits()) {
 
 2482    SourceLocation InitLoc = 
Init->getBeginLoc();
 
 2484    if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(
Init)) {
 
 2488      if (!SubobjectIsDesignatorContext)
 
 2491      HasDesignatedInit = 
true;
 
 2495      bool DesignatedInitFailed = CheckDesignatedInitializer(
 
 2496          Entity, IList, DIE, 0, DeclType, &Field, 
nullptr, Index,
 
 2497          StructuredList, StructuredIndex, 
true, TopLevelObject);
 
 2498      if (DesignatedInitFailed)
 
 2502      DesignatedInitExpr::Designator *D = DIE->getDesignator(0);
 
 2505        InitializedFields.insert(F);
 
 2506        if (!DesignatedInitFailed) {
 
 2515      InitializedSomething = 
true;
 
 2532        if (NumRecordDecls == 1)
 
 2534        if (
const auto *IL = dyn_cast<IntegerLiteral>(I))
 
 2535          return IL->getValue().isZero();
 
 2543        SemaRef.
Diag(InitLoc, diag::err_non_designated_init_used);
 
 2548    if (Field == FieldEnd) {
 
 2554    if (InitializedSomething && RD->
isUnion())
 
 2558    if (
Field->getType()->isIncompleteArrayType())
 
 2561    if (
Field->isUnnamedBitField()) {
 
 2570      InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
 
 2589    InitializedEntity MemberEntity =
 
 2591    CheckSubElementType(MemberEntity, IList, 
Field->getType(), Index,
 
 2592                        StructuredList, StructuredIndex);
 
 2593    InitializedSomething = 
true;
 
 2594    InitializedFields.insert(*Field);
 
 2606  bool IsCDesignatedInitializer =
 
 2607      HasDesignatedInit && !SemaRef.
getLangOpts().CPlusPlus;
 
 2608  if (!VerifyOnly && InitializedSomething && !RD->
isUnion() &&
 
 2610      !IsCDesignatedInitializer) {
 
 2617      if (HasDesignatedInit && InitializedFields.count(*it))
 
 2620      if (!it->isUnnamedBitField() && !it->hasInClassInitializer() &&
 
 2621          !it->getType()->isIncompleteArrayType()) {
 
 2622        auto Diag = HasDesignatedInit
 
 2623                        ? diag::warn_missing_designated_field_initializers
 
 2624                        : diag::warn_missing_field_initializers;
 
 2633  if (!StructuredList && Field != FieldEnd && !RD->
isUnion() &&
 
 2634      !
Field->getType()->isIncompleteArrayType()) {
 
 2635    for (; 
Field != FieldEnd && !hadError; ++
Field) {
 
 2636      if (!
Field->isUnnamedBitField() && !
Field->hasInClassInitializer())
 
 2637        CheckEmptyInitializable(
 
 2658  if (Field == FieldEnd || !
Field->getType()->isIncompleteArrayType() ||
 
 2662  if (CheckFlexibleArrayInit(Entity, IList->
getInit(Index), *Field,
 
 2669  InitializedEntity MemberEntity =
 
 2673      AggrDeductionCandidateParamTypes)
 
 2674    CheckSubElementType(MemberEntity, IList, 
Field->getType(), Index,
 
 2675                        StructuredList, StructuredIndex);
 
 2677    CheckImplicitInitList(MemberEntity, IList, 
Field->getType(), Index,
 
 2678                          StructuredList, StructuredIndex);
 
 2699       PE = IndirectField->
chain_end(); PI != PE; ++PI) {
 
 2715                        &Replacements[0] + Replacements.size());
 
 
 2722  for (
unsigned I = 0; I < NumIndexExprs; ++I)
 
 
 2734class FieldInitializerValidatorCCC final : 
public CorrectionCandidateCallback {
 
 2736  explicit FieldInitializerValidatorCCC(
const RecordDecl *RD)
 
 2739  bool ValidateCandidate(
const TypoCorrection &candidate)
 override {
 
 2744  std::unique_ptr<CorrectionCandidateCallback> clone()
 override {
 
 2745    return std::make_unique<FieldInitializerValidatorCCC>(*
this);
 
 2749  const RecordDecl *
Record;
 
 2792InitListChecker::CheckDesignatedInitializer(
const InitializedEntity &Entity,
 
 2793                                            InitListExpr *IList,
 
 2794                                            DesignatedInitExpr *DIE,
 
 2796                                            QualType &CurrentObjectType,
 
 2798                                            llvm::APSInt *NextElementIndex,
 
 2800                                            InitListExpr *StructuredList,
 
 2801                                            unsigned &StructuredIndex,
 
 2802                                            bool FinishSubobjectInit,
 
 2803                                            bool TopLevelObject) {
 
 2804  if (DesigIdx == DIE->
size()) {
 
 2812             "designator result in direct non-list initialization?");
 
 2815      InitializationSequence 
Seq(SemaRef, Entity, Kind, 
Init,
 
 2817      if (StructuredList) {
 
 2821        UpdateStructuredListElement(StructuredList, StructuredIndex,
 
 2825      if (AggrDeductionCandidateParamTypes)
 
 2826        AggrDeductionCandidateParamTypes->push_back(CurrentObjectType);
 
 2831    bool prevHadError = hadError;
 
 2836    unsigned OldIndex = Index;
 
 2838        dyn_cast_if_present<DesignatedInitExpr>(IList->
getInit(OldIndex));
 
 2841    IList->
setInit(OldIndex, OldDIE->getInit());
 
 2843    CheckSubElementType(Entity, IList, CurrentObjectType, Index, StructuredList,
 
 2844                        StructuredIndex, 
true);
 
 2848    if (IList->
getInit(OldIndex) != OldDIE->getInit())
 
 2849      OldDIE->setInit(IList->
getInit(OldIndex));
 
 2850    IList->
setInit(OldIndex, OldDIE);
 
 2852    return hadError && !prevHadError;
 
 2855  DesignatedInitExpr::Designator *D = DIE->
getDesignator(DesigIdx);
 
 2856  bool IsFirstDesignator = (DesigIdx == 0);
 
 2857  if (IsFirstDesignator ? FullyStructuredList : StructuredList) {
 
 2860    if (IsFirstDesignator)
 
 2861      StructuredList = FullyStructuredList;
 
 2863      Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
 
 2864          StructuredList->getInit(StructuredIndex) : 
nullptr;
 
 2865      if (!ExistingInit && StructuredList->hasArrayFiller())
 
 2866        ExistingInit = StructuredList->getArrayFiller();
 
 2869        StructuredList = getStructuredSubobjectInit(
 
 2870            IList, Index, CurrentObjectType, StructuredList, StructuredIndex,
 
 2872      else if (InitListExpr *
Result = dyn_cast<InitListExpr>(ExistingInit))
 
 2886        diagnoseInitOverride(ExistingInit,
 
 2892          if (DesignatedInitUpdateExpr *E =
 
 2893                  dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
 
 2894            StructuredList = E->getUpdater();
 
 2896            DesignatedInitUpdateExpr *DIUE = 
new (SemaRef.
Context)
 
 2899            StructuredList->updateInit(SemaRef.
Context, StructuredIndex, DIUE);
 
 2908          StructuredList = 
nullptr;
 
 2930        SemaRef.
Diag(Loc, diag::err_field_designator_non_aggr)
 
 2931          << SemaRef.
getLangOpts().CPlusPlus << CurrentObjectType;
 
 2940      if (
auto *FD = dyn_cast_if_present<FieldDecl>(VD)) {
 
 2942      } 
else if (
auto *IFD = dyn_cast_if_present<IndirectFieldDecl>(VD)) {
 
 2963        if (DeclContextLookupResult Lookup = RD->
lookup(FieldName);
 
 2967          SemaRef.
Diag(Lookup.front()->getLocation(),
 
 2968                       diag::note_field_designator_found);
 
 2975        FieldInitializerValidatorCCC CCC(RD);
 
 2976        if (TypoCorrection Corrected = SemaRef.
CorrectTypo(
 
 2979                CorrectTypoKind::ErrorRecovery, RD)) {
 
 2982              SemaRef.
PDiag(diag::err_field_designator_unknown_suggest)
 
 2983                << FieldName << CurrentObjectType);
 
 2984          KnownField = Corrected.getCorrectionDeclAs<FieldDecl>();
 
 2995          SemaRef.
Diag(Loc, diag::err_field_designator_unknown)
 
 3003    unsigned NumBases = 0;
 
 3004    if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
 
 3005      NumBases = CXXRD->getNumBases();
 
 3007    unsigned FieldIndex = NumBases;
 
 3009    for (
auto *FI : RD->
fields()) {
 
 3010      if (FI->isUnnamedBitField())
 
 3026      if (StructuredList) {
 
 3027        FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
 
 3029          assert(StructuredList->getNumInits() == 1
 
 3030                 && 
"A union should never have more than one initializer!");
 
 3032          Expr *ExistingInit = StructuredList->getInit(0);
 
 3035            diagnoseInitOverride(
 
 3043          StructuredList->resizeInits(SemaRef.
Context, 0);
 
 3044          StructuredList->setInitializedFieldInUnion(
nullptr);
 
 3047        StructuredList->setInitializedFieldInUnion(*Field);
 
 3054      InvalidUse = !SemaRef.
CanUseDecl(*Field, TreatUnavailableAsInvalid);
 
 3077    if (IsFirstDesignator && !VerifyOnly && SemaRef.
getLangOpts().CPlusPlus &&
 
 3080         (*NextField)->getFieldIndex() > 
Field->getFieldIndex() + 1)) {
 
 3082      FieldDecl *PrevField = 
nullptr;
 
 3084        if (FI->isUnnamedBitField())
 
 3095                     diag::ext_designated_init_reordered)
 
 3098        unsigned OldIndex = StructuredIndex - 1;
 
 3099        if (StructuredList && OldIndex <= StructuredList->getNumInits()) {
 
 3100          if (Expr *PrevInit = StructuredList->getInit(OldIndex)) {
 
 3101            SemaRef.
Diag(PrevInit->getBeginLoc(),
 
 3102                         diag::note_previous_field_init)
 
 3116    if (StructuredList && FieldIndex >= StructuredList->getNumInits())
 
 3117      StructuredList->resizeInits(SemaRef.
Context, FieldIndex + 1);
 
 3120    if (
Field->getType()->isIncompleteArrayType()) {
 
 3122      if ((DesigIdx + 1) != DIE->
size()) {
 
 3126          DesignatedInitExpr::Designator *NextD
 
 3129                       diag::err_designator_into_flexible_array_member)
 
 3131          SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
 
 3142                       diag::err_flexible_array_init_needs_braces)
 
 3144          SemaRef.
Diag(
Field->getLocation(), diag::note_flexible_array_member)
 
 3151      if (!
Invalid && CheckFlexibleArrayInit(Entity, DIE->
getInit(), *Field,
 
 3161      bool prevHadError = hadError;
 
 3162      unsigned newStructuredIndex = FieldIndex;
 
 3163      unsigned OldIndex = Index;
 
 3166      InitializedEntity MemberEntity =
 
 3168      CheckSubElementType(MemberEntity, IList, 
Field->getType(), Index,
 
 3169                          StructuredList, newStructuredIndex);
 
 3171      IList->
setInit(OldIndex, DIE);
 
 3172      if (hadError && !prevHadError) {
 
 3177        StructuredIndex = FieldIndex;
 
 3182      QualType FieldType = 
Field->getType();
 
 3183      unsigned newStructuredIndex = FieldIndex;
 
 3185      InitializedEntity MemberEntity =
 
 3187      if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
 
 3188                                     FieldType, 
nullptr, 
nullptr, Index,
 
 3189                                     StructuredList, newStructuredIndex,
 
 3190                                     FinishSubobjectInit, 
false))
 
 3201    if (IsFirstDesignator) {
 
 3208      StructuredIndex = FieldIndex;
 
 3212    if (!FinishSubobjectInit)
 
 3220    bool prevHadError = hadError;
 
 3225    CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,
 
 3226                          false, Index, StructuredList, FieldIndex);
 
 3227    return hadError && !prevHadError;
 
 3249        << CurrentObjectType;
 
 3254  Expr *IndexExpr = 
nullptr;
 
 3255  llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
 
 3259    DesignatedEndIndex = DesignatedStartIndex;
 
 3263    DesignatedStartIndex =
 
 3265    DesignatedEndIndex =
 
 3274    if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
 
 3281    DesignatedStartIndex
 
 3282      = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
 
 3283    DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
 
 3285      = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
 
 3286    DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
 
 3287    if (DesignatedEndIndex >= MaxElements) {
 
 3290                     diag::err_array_designator_too_large)
 
 3297    unsigned DesignatedIndexBitWidth =
 
 3299    DesignatedStartIndex =
 
 3300      DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
 
 3301    DesignatedEndIndex =
 
 3302      DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
 
 3303    DesignatedStartIndex.setIsUnsigned(
true);
 
 3304    DesignatedEndIndex.setIsUnsigned(
true);
 
 3307  bool IsStringLiteralInitUpdate =
 
 3308      StructuredList && StructuredList->isStringLiteralInit();
 
 3309  if (IsStringLiteralInitUpdate && VerifyOnly) {
 
 3312    StructuredList = 
nullptr;
 
 3313  } 
else if (IsStringLiteralInitUpdate) {
 
 3316    ASTContext &Context = SemaRef.
Context;
 
 3317    Expr *SubExpr = StructuredList->getInit(0)->IgnoreParenImpCasts();
 
 3323    QualType PromotedCharTy = CharTy;
 
 3326    unsigned PromotedCharTyWidth = Context.
getTypeSize(PromotedCharTy);
 
 3328    if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
 
 3331      if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT);
 
 3332          CAT && CAT->getSize().ult(StrLen))
 
 3333        StrLen = CAT->getZExtSize();
 
 3334      StructuredList->resizeInits(Context, StrLen);
 
 3338      for (
unsigned i = 0, e = StrLen; i != e; ++i) {
 
 3339        llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
 
 3340        Expr *
Init = 
new (Context) IntegerLiteral(
 
 3341            Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
 
 3342        if (CharTy != PromotedCharTy)
 
 3345                                          FPOptionsOverride());
 
 3346        StructuredList->updateInit(Context, i, 
Init);
 
 3355      if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT);
 
 3356          CAT && CAT->getSize().ult(StrLen))
 
 3357        StrLen = CAT->getZExtSize();
 
 3358      StructuredList->resizeInits(Context, StrLen);
 
 3362      for (
unsigned i = 0, e = StrLen; i != e; ++i) {
 
 3363        llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
 
 3364        Expr *
Init = 
new (Context) IntegerLiteral(
 
 3365            Context, CodeUnit, PromotedCharTy, SubExpr->
getExprLoc());
 
 3366        if (CharTy != PromotedCharTy)
 
 3369                                          FPOptionsOverride());
 
 3370        StructuredList->updateInit(Context, i, 
Init);
 
 3377  if (StructuredList &&
 
 3378      DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
 
 3379    StructuredList->resizeInits(SemaRef.
Context,
 
 3380                                DesignatedEndIndex.getZExtValue() + 1);
 
 3386  unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
 
 3387  unsigned OldIndex = Index;
 
 3389  InitializedEntity ElementEntity =
 
 3392  while (DesignatedStartIndex <= DesignatedEndIndex) {
 
 3398    if (CheckDesignatedInitializer(
 
 3399            ElementEntity, IList, DIE, DesigIdx + 1, ElementType, 
nullptr,
 
 3400            nullptr, Index, StructuredList, ElementIndex,
 
 3401            FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),
 
 3406    ++DesignatedStartIndex;
 
 3407    ElementIndex = DesignatedStartIndex.getZExtValue();
 
 3412  if (IsFirstDesignator) {
 
 3413    if (NextElementIndex)
 
 3414      *NextElementIndex = DesignatedStartIndex;
 
 3415    StructuredIndex = ElementIndex;
 
 3419  if (!FinishSubobjectInit)
 
 3423  bool prevHadError = hadError;
 
 3424  CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
 
 3426                 StructuredList, ElementIndex);
 
 3427  return hadError && !prevHadError;
 
 3433InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, 
unsigned Index,
 
 3434                                            QualType CurrentObjectType,
 
 3435                                            InitListExpr *StructuredList,
 
 3436                                            unsigned StructuredIndex,
 
 3437                                            SourceRange InitRange,
 
 3438                                            bool IsFullyOverwritten) {
 
 3439  if (!StructuredList)
 
 3442  Expr *ExistingInit = 
nullptr;
 
 3443  if (StructuredIndex < StructuredList->getNumInits())
 
 3444    ExistingInit = StructuredList->
getInit(StructuredIndex);
 
 3446  if (InitListExpr *
Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
 
 3455    if (!IsFullyOverwritten)
 
 3478    diagnoseInitOverride(ExistingInit, InitRange);
 
 3481  unsigned ExpectedNumInits = 0;
 
 3482  if (Index < IList->getNumInits()) {
 
 3483    if (
auto *
Init = dyn_cast_or_null<InitListExpr>(IList->
getInit(Index)))
 
 3484      ExpectedNumInits = 
Init->getNumInits();
 
 3490      createInitListExpr(CurrentObjectType, InitRange, ExpectedNumInits);
 
 3499InitListChecker::createInitListExpr(QualType CurrentObjectType,
 
 3500                                    SourceRange InitRange,
 
 3501                                    unsigned ExpectedNumInits) {
 
 3505  QualType ResultType = CurrentObjectType;
 
 3508  Result->setType(ResultType);
 
 3511  unsigned NumElements = 0;
 
 3513  if (
const ArrayType *AType
 
 3515    if (
const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
 
 3516      NumElements = CAType->getZExtSize();
 
 3519      if (NumElements > ExpectedNumInits)
 
 3522  } 
else if (
const VectorType *VType = CurrentObjectType->
getAs<VectorType>()) {
 
 3523    NumElements = VType->getNumElements();
 
 3525    NumElements = numStructUnionElements(CurrentObjectType);
 
 3537void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
 
 3538                                                  unsigned &StructuredIndex,
 
 3541  if (!StructuredList)
 
 3545                                                  StructuredIndex, 
expr)) {
 
 3551      diagnoseInitOverride(PrevInit, 
expr->getSourceRange());
 
 3560  InitListChecker Check(*
this, Entity, From, 
Type, 
true,
 
 3563  return !Check.HadError();
 
 
 3580  if (Result.isInvalid())
 
 3584    return S.
Diag(Loc, diag::err_array_designator_negative)
 
 3587  Value.setIsUnsigned(
true);
 
 
 3606      Designators.push_back(ASTDesignator::CreateFieldDesignator(
 
 3610      llvm::APSInt IndexValue;
 
 3616        Designators.push_back(ASTDesignator::CreateArrayDesignator(
 
 3618        InitExpressions.push_back(Index);
 
 3623      llvm::APSInt StartValue;
 
 3624      llvm::APSInt EndValue;
 
 3629      if (!StartDependent)
 
 3635      if (!StartIndex || !EndIndex)
 
 3639        if (StartDependent || EndDependent) {
 
 3641        } 
else if (StartValue.getBitWidth() > EndValue.getBitWidth())
 
 3642          EndValue = EndValue.extend(StartValue.getBitWidth());
 
 3643        else if (StartValue.getBitWidth() < EndValue.getBitWidth())
 
 3644          StartValue = StartValue.extend(EndValue.getBitWidth());
 
 3646        if (!StartDependent && !EndDependent && EndValue < StartValue) {
 
 3652          Designators.push_back(ASTDesignator::CreateArrayRangeDesignator(
 
 3655          InitExpressions.push_back(StartIndex);
 
 3656          InitExpressions.push_back(EndIndex);
 
 3666                                    EqualOrColonLoc, GNUSyntax,
 
 
 3674InitializedEntity::InitializedEntity(
ASTContext &Context, 
unsigned Index,
 
 3676  : Parent(&Parent), Index(Index)
 
 3679    Kind = EK_ArrayElement;
 
 3680    Type = AT->getElementType();
 
 3682    Kind = EK_VectorElement;
 
 3683    Type = VT->getElementType();
 
 3685    Kind = EK_MatrixElement;
 
 3686    Type = MT->getElementType();
 
 3688    const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
 
 3689    assert(CT && 
"Unexpected type");
 
 3690    Kind = EK_ComplexElement;
 
 3691    Type = CT->getElementType();
 
 3698                                  bool IsInheritedVirtualBase,
 
 3699                                  const InitializedEntity *Parent) {
 
 3700  InitializedEntity 
Result;
 
 3703  Result.Base = {
Base, IsInheritedVirtualBase};
 
 
 3721    return Variable.VariableOrMember->getDeclName();
 
 3744  llvm_unreachable(
"Invalid EntityKind!");
 
 
 3779  llvm_unreachable(
"Invalid EntityKind!");
 
 
 3815unsigned InitializedEntity::dumpImpl(raw_ostream &OS)
 const {
 
 3818  for (
unsigned I = 0; I != Depth; ++I)
 
 3835  case EK_New: OS << 
"New"; 
break;
 
 3839  case EK_Base: OS << 
"Base"; 
break;
 
 3844    OS << 
"MatrixElement " << 
Index;
 
 3849    OS << 
"Block (lambda)";
 
 3852    OS << 
"LambdaCapture ";
 
 3859    D->printQualifiedName(OS);
 
 3868  dumpImpl(llvm::errs());
 
 
 3923  for (
const Step &S : llvm::reverse(Steps)) {
 
 
 3984  llvm_unreachable(
"Invalid EntityKind!");
 
 
 3992InitializationSequence
 
 3995                                   bool HadMultipleCandidates) {
 
 
 4020                                                     bool BindingTemporary) {
 
 
 4045                                              bool HadMultipleCandidates) {
 
 
 4090    bool TopLevelOfInitList) {
 
 
 4108    bool HadMultipleCandidates, 
bool FromInitList, 
bool AsInitList) {
 
 
 4159  Steps.insert(Steps.begin(), S);
 
 
 4220         "Can only unwrap trivial init lists.");
 
 4224  Steps.insert(Steps.begin(), S);
 
 
 4230         "Can only rewrap trivial init lists.");
 
 4234  Steps.insert(Steps.begin(), S);
 
 
 4245  this->Failure = Failure;
 
 4246  this->FailedOverloadResult = 
Result;
 
 
 4267  if (!
Init.empty()) {
 
 
 4287           "consuming an object of unretainable type?");
 
 
 4307                         bool TreatUnavailableAsInvalid) {
 
 4322  Expr *OVEAsExpr = &OVE;
 
 4325                          TreatUnavailableAsInvalid);
 
 
 4331                                  const InitializedEntity &Entity,
 
 4332                                  const InitializationKind &Kind,
 
 4333                                  InitListExpr *InitList,
 
 4335                                  bool TreatUnavailableAsInvalid);
 
 4346                                           bool TreatUnavailableAsInvalid) {
 
 4367                        TreatUnavailableAsInvalid);
 
 
 4394    bool CopyInitializing, 
bool AllowExplicit, 
bool OnlyListConstructors,
 
 4395    bool IsListInit, 
bool RequireActualConstructor,
 
 4396    bool SecondStepOfCopyInit = 
false) {
 
 4402    if (!Info.Constructor || Info.Constructor->isInvalidDecl())
 
 4419    bool SuppressUserConversions =
 
 4420        SecondStepOfCopyInit ||
 
 4424    if (Info.ConstructorTmpl)
 
 4426          Info.ConstructorTmpl, Info.FoundDecl,
 
 4427           nullptr, Args, CandidateSet, SuppressUserConversions,
 
 4428          false, AllowExplicit);
 
 4437      bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
 
 4441                             CandidateSet, SuppressUserConversions,
 
 4442                             false, AllowExplicit,
 
 4458  if (S.
getLangOpts().CPlusPlus17 && Args.size() == 1 &&
 
 4459      !RequireActualConstructor && !SecondStepOfCopyInit) {
 
 4461    auto *SourceRD = 
Initializer->getType()->getAsCXXRecordDecl();
 
 4463      const auto &Conversions = SourceRD->getVisibleConversionFunctions();
 
 4464      for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
 
 4478              ConvTemplate, I.getPair(), ActingDC, 
Initializer, DestType,
 
 4479              CandidateSet, AllowExplicit, AllowExplicit,
 
 4483                                   DestType, CandidateSet, AllowExplicit,
 
 
 4510                                         bool IsListInit = 
false,
 
 4511                                         bool IsInitListCopy = 
false) {
 
 4512  assert(((!IsListInit && !IsInitListCopy) ||
 
 4514         "IsListInit/IsInitListCopy must come with a single initializer list " 
 4527  bool RequireActualConstructor =
 
 4533  bool CopyElisionPossible = 
false;
 
 4534  auto ElideConstructor = [&] {
 
 4550  if (S.
getLangOpts().CPlusPlus17 && !RequireActualConstructor &&
 
 4551      UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isPRValue() &&
 
 4573      assert(!IsInitListCopy &&
 
 4574             "IsInitListCopy only possible with aggregate types");
 
 4575      CopyElisionPossible = 
true;
 
 4589  bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
 
 4599  bool AsInitializerList = 
false;
 
 4611    AsInitializerList = 
true;
 
 4617          S, Kind.getLocation(), Args, CandidateSet, DestType, Ctors, Best,
 
 4618          CopyInitialization, AllowExplicit,
 
 4619          true, IsListInit, RequireActualConstructor);
 
 4634    AsInitializerList = 
false;
 
 4636        S, Kind.getLocation(), UnwrappedArgs, CandidateSet, DestType, Ctors,
 
 4637        Best, CopyInitialization, AllowExplicit,
 
 4638        false, IsListInit, RequireActualConstructor);
 
 4650  bool HadMultipleCandidates = (CandidateSet.
size() > 1);
 
 4654  if (
auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
 
 4656    QualType ConvType = CD->getConversionType();
 
 4658           "should not have selected this conversion function");
 
 4660                                   HadMultipleCandidates);
 
 4674        DestRecordDecl->isAggregate() &&
 
 4675        DestRecordDecl->hasUninitializedExplicitInitFields() &&
 
 4677      S.
Diag(Kind.getLocation(), diag::warn_field_requires_explicit_init)
 
 4678          <<  1 << DestRecordDecl;
 
 4703    if (IsListInit && !Kind.AllowExplicit() && CtorDecl->
isExplicit()) {
 
 4723      Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,
 
 4724      IsListInit | IsInitListCopy, AsInitializerList);
 
 
 4728    Sema &S, 
const InitializedEntity &Entity, 
const InitializationKind &Kind,
 
 4744    bool IsAggrListInit) {
 
 4762                               Sequence, 
false, IsAggrListInit);
 
 
 4790    bool HadMultipleCandidates = 
false;
 
 4793                                               UnqualifiedTargetType,
 
 4795                                               &HadMultipleCandidates)) {
 
 4797                                                HadMultipleCandidates);
 
 4798      SourceType = Fn->getType();
 
 
 4809                                           const InitializedEntity &Entity,
 
 4810                                           const InitializationKind &Kind,
 
 4812                                           QualType cv1T1, QualType T1,
 
 4814                                           QualType cv2T2, QualType T2,
 
 4817                                           bool TopLevelOfInitList);
 
 4820                                   const InitializedEntity &Entity,
 
 4821                                   const InitializationKind &Kind,
 
 4823                                   InitListExpr *InitList = 
nullptr);
 
 4831                                           bool TreatUnavailableAsInvalid) {
 
 4871                                     T1Quals, cv2T2, T2, T2Quals, Sequence,
 
 4879    if (!Sequence.
steps().empty())
 
 4902                        TreatUnavailableAsInvalid);
 
 
 4934                                  bool TreatUnavailableAsInvalid) {
 
 4951                                   TreatUnavailableAsInvalid);
 
 4989      !IsDesignatedInit) {
 
 5000        Expr *InitListAsExpr = InitList;
 
 5002            S, Entity, SubKind, InitListAsExpr, DestType, Sequence,
 
 5023            "Deduced to other type?");
 
 5025               "List-initialize structured bindings but not " 
 5026               "direct-list-initialization?");
 
 5031                     Entity, SubInit[0], DestType, Sequence,
 
 5032                     TreatUnavailableAsInvalid);
 
 5048                                TreatUnavailableAsInvalid);
 
 5081                                         TreatUnavailableAsInvalid))
 
 5085      Expr *InitListAsExpr = InitList;
 
 5087                                   DestType, Sequence, 
true);
 
 5153    if (
Init->getType()->isRecordType() ||
 
 5164                              TreatUnavailableAsInvalid);
 
 5171  InitListChecker CheckInitList(S, Entity, InitList,
 
 5172          DestType, 
true, TreatUnavailableAsInvalid);
 
 5173  if (CheckInitList.HadError()) {
 
 
 5195         "Must have incompatible references when binding via conversion");
 
 5206  bool AllowExplicitCtors = 
false;
 
 5207  bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
 
 5212    if (T1RecordDecl->isInvalidDecl())
 
 5218      if (!Info.Constructor)
 
 5221      if (!Info.Constructor->isInvalidDecl() &&
 
 5222          Info.Constructor->isConvertingConstructor(
true)) {
 
 5223        if (Info.ConstructorTmpl)
 
 5225              Info.ConstructorTmpl, Info.FoundDecl,
 
 5228               false, AllowExplicitCtors);
 
 5231              Info.Constructor, Info.FoundDecl, 
Initializer, CandidateSet,
 
 5233               false, AllowExplicitCtors);
 
 5240    if (T2RecordDecl->isInvalidDecl())
 
 5244    const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
 
 5245    for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
 
 5264      if ((AllowRValues ||
 
 5268              ConvTemplate, I.getPair(), ActingDC, 
Initializer, DestType,
 
 5270              false, AllowExplicitConvs);
 
 5273              Conv, I.getPair(), ActingDC, 
Initializer, DestType, CandidateSet,
 
 5274              false, AllowExplicitConvs);
 
 5295    cv3T3 = Function->getReturnType();
 
 5307  bool HadMultipleCandidates = (CandidateSet.
size() > 1);
 
 5309                                 HadMultipleCandidates);
 
 5320           "should not have conversion after constructor");
 
 5324    ICS.
Standard = Best->FinalConversion;
 
 5345  if (RefConv & Sema::ReferenceConversions::DerivedToBase)
 
 5347  else if (RefConv & Sema::ReferenceConversions::ObjC)
 
 5349  else if (RefConv & Sema::ReferenceConversions::Function)
 
 5351  else if (RefConv & Sema::ReferenceConversions::Qualification) {
 
 
 5360                                           const InitializedEntity &Entity,
 
 5368                                       bool TopLevelOfInitList) {
 
 5386                                 T1Quals, cv2T2, T2, T2Quals, Sequence,
 
 5387                                 TopLevelOfInitList);
 
 
 5411                                           bool TopLevelOfInitList) {
 
 5435  if (isLValueRef || T1Function) {
 
 5438         (Kind.isCStyleOrFunctionalCast() &&
 
 5442      if (RefConv & (Sema::ReferenceConversions::DerivedToBase |
 
 5443                     Sema::ReferenceConversions::ObjC)) {
 
 5446        if (RefConv & (Sema::ReferenceConversions::Qualification))
 
 5450        if (RefConv & Sema::ReferenceConversions::DerivedToBase)
 
 5454      } 
else if (RefConv & Sema::ReferenceConversions::Qualification) {
 
 5458      } 
else if (RefConv & Sema::ReferenceConversions::Function) {
 
 5478        (isLValueRef || InitCategory.
isRValue())) {
 
 5483             isLValueRef, Sequence);
 
 5518      switch (RefRelationship) {
 
 5521          FK = InitializationSequence::
 
 5522              FK_NonConstLValueReferenceBindingToBitfield;
 
 5524          FK = InitializationSequence::
 
 5525              FK_NonConstLValueReferenceBindingToVectorElement;
 
 5527          FK = InitializationSequence::
 
 5528              FK_NonConstLValueReferenceBindingToMatrixElement;
 
 5530          llvm_unreachable(
"unexpected kind of compatible initializer");
 
 5536        FK = InitializationSequence::
 
 5537            FK_NonConstLValueReferenceBindingToUnrelated;
 
 5554       (Kind.isCStyleOrFunctionalCast() &&
 
 5583    auto T1QualsIgnoreAS = T1Quals;
 
 5584    auto T2QualsIgnoreAS = T2Quals;
 
 5586      T1QualsIgnoreAS.removeAddressSpace();
 
 5587      T2QualsIgnoreAS.removeAddressSpace();
 
 5590    if (T1QualsIgnoreAS != T2QualsIgnoreAS)
 
 5600      cv1T4 = cv1T4WithAS;
 
 5605    if (RefConv & Sema::ReferenceConversions::DerivedToBase)
 
 5607    else if (RefConv & Sema::ReferenceConversions::ObjC)
 
 5609    else if (RefConv & Sema::ReferenceConversions::Qualification) {
 
 5626           isLValueRef, Sequence);
 
 5666                              Sema::AllowedExplicit::None,
 
 5668                              Kind.isCStyleOrFunctionalCast(),
 
 5687                                       TopLevelOfInitList);
 
 5696      ((T1CVRQuals | T2CVRQuals) != T1CVRQuals ||
 
 
 5741  assert((!InitList || InitList->
getNumInits() == 0) &&
 
 5742         "Shouldn't use value-init for non-empty init lists");
 
 5748  assert(!
T->isVoidType() && 
"Cannot value-init void");
 
 5753  if (
auto *ClassDecl = 
T->getAsCXXRecordDecl()) {
 
 5754    bool NeedZeroInitialization = 
true;
 
 5769      NeedZeroInitialization = 
false;
 
 5777    if (NeedZeroInitialization)
 
 5791        ClassDecl->hasUninitializedReferenceMember()) {
 
 5799    Expr *InitListAsExpr = InitList;
 
 5801    bool InitListSyntax = InitList;
 
 5806        S, Entity, Kind, Args, 
T, Entity.
getType(), Sequence, InitListSyntax);
 
 
 5855  unsigned EntityIndexToProcess = 0;
 
 5858  Expr *ArrayFiller = 
nullptr;
 
 5859  FieldDecl *InitializedFieldInUnion = 
nullptr;
 
 5863                                     Expr *Arg, 
Expr **InitExpr = 
nullptr) {
 
 5865        S, SubEntity, SubKind,
 
 5881      ER = IS.
Perform(S, SubEntity, SubKind,
 
 5888        *InitExpr = ER.
get();
 
 5890        InitExprs.push_back(ER.
get());
 
 5897    uint64_t ArrayLength;
 
 5905      ArrayLength = CAT->getZExtSize();
 
 5906      ResultType = Entity.
getType();
 
 5913      const Expr *SE = VAT->getSizeExpr();
 
 5919      ArrayLength = Args.size();
 
 5921    EntityIndexToProcess = ArrayLength;
 
 5925    for (
Expr *E : Args) {
 
 5930      if (!HandleInitializedEntity(SubEntity, SubKind, E))
 
 5938          Kind.getLocation(), Kind.getLocation(), Kind.getLocation(), 
true);
 
 5939      if (!HandleInitializedEntity(SubEntity, SubKind, 
nullptr, &ArrayFiller))
 
 5943    if (ResultType.
isNull()) {
 
 5963        if (EntityIndexToProcess < Args.size()) {
 
 5969          Expr *E = Args[EntityIndexToProcess];
 
 5972          if (!HandleInitializedEntity(SubEntity, SubKind, E))
 
 5980              Kind.getLocation(), Kind.getLocation(), Kind.getLocation(),
 
 5982          if (!HandleInitializedEntity(SubEntity, SubKind, 
nullptr))
 
 5985        EntityIndexToProcess++;
 
 5998      if (EntityIndexToProcess < Args.size()) {
 
 6000        Expr *E = Args[EntityIndexToProcess];
 
 6018        if (!HandleInitializedEntity(SubEntity, SubKind, E))
 
 6026          InitializedFieldInUnion = FD;
 
 6027          EntityIndexToProcess = 1;
 
 6033        if (!VerifyOnly && FD->
hasAttr<ExplicitInitAttr>() &&
 
 6035          S.
Diag(Kind.getLocation(), diag::warn_field_requires_explicit_init)
 
 6046                Kind.getParenOrBraceRange().getEnd(), FD);
 
 6050            InitExprs.push_back(DIE.
get());
 
 6060              S.
Diag(SR.
getEnd(), diag::err_init_reference_member_uninitialized)
 
 6067              Kind.getLocation(), Kind.getLocation(), Kind.getLocation(), 
true);
 
 6068          if (!HandleInitializedEntity(SubEntity, SubKind, 
nullptr))
 
 6072      EntityIndexToProcess++;
 
 6074    ResultType = Entity.
getType();
 
 6079  if (EntityIndexToProcess < Args.size()) {
 
 6083      int InitKind = 
T->isArrayType() ? 0 : 
T->isUnionType() ? 4 : 5;
 
 6084      SourceRange ExcessInitSR(Args[EntityIndexToProcess]->getBeginLoc(),
 
 6085                               Args.back()->getEndLoc());
 
 6086      S.
Diag(Kind.getLocation(), diag::err_excess_initializers)
 
 6087          << InitKind << ExcessInitSR;
 
 6095  } 
else if (Result) {
 
 6101      CPLIE->setArrayFiller(ArrayFiller);
 
 6102    if (InitializedFieldInUnion)
 
 6103      CPLIE->setInitializedFieldInUnion(InitializedFieldInUnion);
 
 6105    S.
Diag(Kind.getLocation(),
 
 6106           diag::warn_cxx17_compat_aggregate_init_paren_list)
 
 6107        << Kind.getLocation() << SR << ResultType;
 
 
 6119                                     bool TopLevelOfInitList) {
 
 6120  assert(!DestType->
isReferenceType() && 
"References are handled elsewhere");
 
 6123         "Must have a class type to perform a user-defined conversion");
 
 6133  bool AllowExplicit = Kind.AllowExplicit();
 
 6143        if (!Info.Constructor)
 
 6146        if (!Info.Constructor->isInvalidDecl() &&
 
 6147            Info.Constructor->isConvertingConstructor(
true)) {
 
 6148          if (Info.ConstructorTmpl)
 
 6150                Info.ConstructorTmpl, Info.FoundDecl,
 
 6153                 false, AllowExplicit);
 
 6158                                    false, AllowExplicit);
 
 6174      const auto &Conversions =
 
 6176      for (
auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
 
 6191              ConvTemplate, I.getPair(), ActingDC, 
Initializer, DestType,
 
 6192              CandidateSet, AllowExplicit, AllowExplicit);
 
 6195                                   DestType, CandidateSet, AllowExplicit,
 
 6221  bool HadMultipleCandidates = (CandidateSet.
size() > 1);
 
 6229                                   HadMultipleCandidates);
 
 6256  QualType ConvType = Function->getCallResultType();
 
 6258                                 HadMultipleCandidates);
 
 6271        Function->getReturnType()->isReferenceType() ||
 
 6281  assert(Best->HasFinalConversion);
 
 6282  if (Best->FinalConversion.First || Best->FinalConversion.Second ||
 
 6283      Best->FinalConversion.Third) {
 
 6286    ICS.
Standard = Best->FinalConversion;
 
 
 6296                                         bool isAddressOf, 
bool &isWeakAccess) {
 
 6302    if (op->getOpcode() == UO_AddrOf)
 
 6307  } 
else if (
CastExpr *ce = dyn_cast<CastExpr>(e)) {
 
 6308    switch (ce->getCastKind()) {
 
 6311    case CK_LValueBitCast:
 
 6315    case CK_ArrayToPointerDecay:
 
 6318    case CK_NullToPointer:
 
 6330      isWeakAccess = 
true;
 
 
 6364  bool isWeakAccess = 
false;
 
 6368  if (S.
getLangOpts().ObjCAutoRefCount && isWeakAccess)
 
 
 6388  if (!Context.hasSameType(Dest->
getElementType(), Source->getElementType()))
 
 
 6400  bool ArrayDecay = 
false;
 
 6405    ArgPointee = ArgArrayType->getElementType();
 
 6417  bool ShouldCopy = 
true;
 
 
 6457  std::optional<llvm::APSInt> 
Value = 
Init->getIntegerConstantExpr(Ctx);
 
 
 6488          "cl_intel_device_side_avc_motion_estimation", S.
getLangOpts()) &&
 
 6490    if (DestType->isOCLIntelSubgroupAVCMcePayloadType() ||
 
 6491        DestType->isOCLIntelSubgroupAVCMceResultType())
 
 
 6505    MultiExprArg Args, 
bool TopLevelOfInitList, 
bool TreatUnavailableAsInvalid)
 
 6509                 TreatUnavailableAsInvalid);
 
 
 6515  auto *DRE = dyn_cast<DeclRefExpr>(E);
 
 
 6586                                            bool TopLevelOfInitList,
 
 6587                                            bool TreatUnavailableAsInvalid) {
 
 6594  for (
unsigned I = 0, E = Args.size(); I != E; ++I)
 
 6595    if (Args[I]->
getType()->isNonOverloadPlaceholderType()) {
 
 6602      Args[I] = result.
get();
 
 6624  if (Args.size() == 1) {
 
 6642                            TreatUnavailableAsInvalid);
 
 6651      if (Rec->hasUninitializedExplicitInitFields()) {
 
 6663      if (Var && !
Initializer && !Rec->isUnion() && !Rec->isInvalidDecl()) {
 
 6665          unsigned DiagID = diag::warn_default_init_const_field_unsafe;
 
 6668            DiagID = diag::warn_default_init_const_field;
 
 6671              diag::warn_cxx_compat_hack_fake_diagnostic_do_not_emit,
 
 6675          S.
Diag(FD->
getLocation(), diag::note_default_init_const_member) << FD;
 
 6688    if (Args.size() != 1)
 
 6698                                 TopLevelOfInitList);
 
 6723    const ArrayType *DestAT = Context.getAsArrayType(DestType);
 
 6761                     TreatUnavailableAsInvalid);
 
 6773                   TreatUnavailableAsInvalid);
 
 6799                            *
this, TreatUnavailableAsInvalid);
 
 6801    } 
else if (S.
getLangOpts().CPlusPlus20 && !TopLevelOfInitList &&
 
 6817  bool allowObjCWritebackConversion = S.
getLangOpts().ObjCAutoRefCount &&
 
 6826    assert(
Initializer && 
"Initializer must be non-null");
 
 6828    if (allowObjCWritebackConversion &&
 
 6852         (Context.hasSameUnqualifiedType(SourceType, DestType) ||
 
 6854                                          SourceType, DestType))))) {
 
 6864      assert(
Initializer && 
"Initializer must be non-null");
 
 6866                               TopLevelOfInitList);
 
 6871  assert(Args.size() >= 1 && 
"Zero-argument case handled above");
 
 6879       !Context.hasSameUnqualifiedType(SourceType, DestType))) {
 
 6882                     Args.back()->getEndLoc());
 
 6886                          TreatUnavailableAsInvalid);
 
 6891  if (Args.size() > 1) {
 
 6902    assert(
Initializer && 
"Initializer must be non-null");
 
 6905    bool NeedAtomicConversion = 
false;
 
 6907      if (Context.hasSameUnqualifiedType(SourceType, 
Atomic->getValueType()) ||
 
 6909                          Atomic->getValueType())) {
 
 6910        DestType = 
Atomic->getValueType();
 
 6911        NeedAtomicConversion = 
true;
 
 6916                             TopLevelOfInitList);
 
 6918    if (!
Failed() && NeedAtomicConversion)
 
 6945                              Sema::AllowedExplicit::None,
 
 6947                              Kind.isCStyleOrFunctionalCast(),
 
 6948                              allowObjCWritebackConversion);
 
 6956    bool ShouldCopy = 
true;
 
 6972  } 
else if (ICS.
isBad()) {
 
 6978    else if (
Initializer->getType()->isFunctionType() &&
 
 
 6991  for (
auto &S : Steps)
 
 
 6999                                            bool Diagnose = 
false) {
 
 7051  llvm_unreachable(
"Invalid EntityKind!");
 
 
 7086  llvm_unreachable(
"missed an InitializedEntity kind?");
 
 
 7121  llvm_unreachable(
"missed an InitializedEntity kind?");
 
 
 7161  llvm_unreachable(
"missed an InitializedEntity kind?");
 
 
 7188                             bool IsExtraneousCopy) {
 
 7193  auto *Class = 
T->getAsCXXRecordDecl();
 
 7211      S, Loc, CurInitExpr, CandidateSet, 
T, Ctors, Best,
 
 7223                             ? diag::ext_rvalue_to_reference_temp_copy_no_viable
 
 7224                             : diag::err_temp_copy_no_viable)
 
 7242    S.
Diag(Loc, diag::err_temp_copy_deleted)
 
 7249  bool HadMultipleCandidates = CandidateSet.
size() > 1;
 
 7258  if (IsExtraneousCopy) {
 
 7269    for (
unsigned I = 1, N = 
Constructor->getNumParams(); I != N; ++I) {
 
 7272                                diag::err_call_incomplete_argument))
 
 7313          Best->Function->getParamDecl(0)->getType().getNonReferenceType(),
 
 7318      Loc, 
T, Best->FoundDecl, 
Constructor, Elidable, ConstructorArgs,
 
 7319      HadMultipleCandidates,
 
 
 7335                                           Expr *CurInitExpr) {
 
 7353      S, Loc, CurInitExpr, CandidateSet, CurInitExpr->
getType(), Ctors, Best,
 
 7366                             Best->FoundDecl, Entity, 
Diag);
 
 
 7387void InitializationSequence::PrintInitLocationNote(
Sema &S,
 
 7402           diag::note_method_return_type_change)
 
 7420  switch (Kind.getKind()) {
 
 7426    return NumArgs != 1;
 
 
 7438                                 bool &ConstructorInitRequiresZeroInit,
 
 7439                                 bool IsListInitialization,
 
 7440                                 bool IsStdInitListInitialization,
 
 7443  unsigned NumArgs = Args.size();
 
 7450  SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
 
 7451                         ? Kind.getEqualLoc()
 
 7452                         : Kind.getLocation();
 
 7458    assert(
Constructor->getParent() && 
"No parent class for constructor.");
 
 7475  bool AllowExplicitConv =
 
 7476      Kind.AllowExplicit() && !Kind.isCopyInit() && Args.size() == 1 &&
 
 7481  if (NumArgs == 1 && !Kind.isExplicitCast())
 
 7483        Entity.
getType(), Args.front()->getType(), Kind.getLocation());
 
 7488                                ConstructorArgs, AllowExplicitConv,
 
 7489                                IsListInitialization))
 
 7503          if (I >= ConstructorArgs.size() && FD->
hasAttr<ExplicitInitAttr>() &&
 
 7505            S.
Diag(Loc, diag::warn_field_requires_explicit_init)
 
 7520        : Kind.getParenOrBraceRange();
 
 7523    if (
auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(
 
 7533            ConstructorArgs, ParenOrBraceRange, HadMultipleCandidates,
 
 7534            IsListInitialization, IsStdInitListInitialization,
 
 7535            ConstructorInitRequiresZeroInit),
 
 7551    if (IsListInitialization)
 
 7552      ParenOrBraceRange = 
SourceRange(LBraceLoc, RBraceLoc);
 
 7554      ParenOrBraceRange = Kind.getParenOrBraceRange();
 
 7563                                        HadMultipleCandidates,
 
 7564                                        IsListInitialization,
 
 7565                                        IsStdInitListInitialization,
 
 7566                                        ConstructorInitRequiresZeroInit,
 
 7574                                        HadMultipleCandidates,
 
 7575                                        IsListInitialization,
 
 7576                                        IsStdInitListInitialization,
 
 7577                                        ConstructorInitRequiresZeroInit,
 
 
 7608                                        const Expr *PostInit);
 
 7615                                    bool IsReturnStmt) {
 
 7626  unsigned DiagID = 0;
 
 7656    if (VD->
hasAttr<BlocksAttr>())
 
 7670      DiagID = diag::warn_redundant_move_on_return;
 
 7672      DiagID = diag::warn_pessimizing_move_on_return;
 
 7674    DiagID = diag::warn_pessimizing_move_on_initialization;
 
 
 7716    if (UO->getOpcode() == UO_Deref &&
 
 7717        UO->getSubExpr()->IgnoreParenCasts()->
 
 7720                          S.
PDiag(diag::warn_binding_null_to_reference)
 
 7721                            << UO->getSubExpr()->getSourceRange());
 
 
 7727                                     bool BoundToLvalueReference) {
 
 7737  Cleanup.setExprNeedsCleanups(
false);
 
 
 7773    if (!PointeeTy.isNull() &&
 
 7774        PointeeTy.getAddressSpace() != ExprPointeeTy.getAddressSpace())
 
 7775      CK = CK_AddressSpaceConversion;
 
 7777    CK = CK_AddressSpaceConversion;
 
 
 7792  if (!ZeroInitializationFixit.empty()) {
 
 7794    const auto *VD = dyn_cast_or_null<VarDecl>(D);
 
 7800    if (!DestType->
isRecordType() && VD && VD->isConstexpr()) {
 
 7802      S.
Diag(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)
 
 7805                                        ZeroInitializationFixit);
 
 7807      unsigned DiagID = diag::err_default_init_const;
 
 7809        DiagID = diag::ext_default_init_const;
 
 7811      S.
Diag(Kind.getLocation(), DiagID)
 
 7814                                        ZeroInitializationFixit);
 
 7836              ArrayT->getElementType(),
 
 7837              nullptr, ArrayT->getSizeModifier(),
 
 7838              ArrayT->getIndexTypeCVRQualifiers());
 
 7842        !Kind.isExplicitCast()) {
 
 7844      SourceRange ParenRange = Kind.getParenOrBraceRange();
 
 7849           Kind.isExplicitCast() ||
 
 7865    S.
Diag(
Init->getBeginLoc(), diag::warn_cxx98_compat_reference_list_init)
 
 7866        << 
Init->getSourceRange();
 
 7869  if (S.
getLangOpts().MicrosoftExt && Args.size() == 1 &&
 
 7875    S.
Diag(
Init->getBeginLoc(), diag::ext_init_from_predefined) << 
Init;
 
 7886    S.
Diag(Args[0]->getBeginLoc(), diag::err_opencl_atomic_init)
 
 7905  bool IsHLSLVectorOrMatrixInit =
 
 7909  (void)IsHLSLVectorOrMatrixInit;
 
 7914  switch (Steps.front().Kind) {
 
 7948    assert(Args.size() == 1 || IsHLSLVectorOrMatrixInit);
 
 7967      isa_and_nonnull<InitListExpr>(CurInit.
get()));
 
 7972  auto checkAbstractType = [&](
QualType T) -> 
bool {
 
 7977                                    diag::err_allocation_of_abstract_type);
 
 7982  bool ConstructorInitRequiresZeroInit = 
false;
 
 8015      bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
 
 8027                                         CK_DerivedToBase, CurInit.
get(),
 
 8043        if (
auto *DRE = dyn_cast<DeclRefExpr>(CurInit.
get()->
IgnoreParens())) {
 
 8044          if (
auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
 
 8057      assert(CurInit.
get()->
isPRValue() && 
"not a temporary");
 
 8115      bool CreatedObject = 
false;
 
 8132            HadMultipleCandidates,
 
 8144        CastKind = CK_ConstructorConversion;
 
 8145        CreatedObject = 
true;
 
 8155                                           HadMultipleCandidates);
 
 8159        CastKind = CK_UserDefinedConversion;
 
 8163      if (CreatedObject && checkAbstractType(CurInit.
get()->
getType()))
 
 8180        if (
auto *
Record = 
T->castAsCXXRecordDecl()) {
 
 8183                                  S.
PDiag(diag::err_access_dtor_temp) << 
T);
 
 8207             "function reference should be lvalue");
 
 8213      assert(CurInit.
get()->
isPRValue() && 
"cannot convert glvalue to atomic");
 
 8221      if (
const auto *FromPtrType =
 
 8224          if (FromPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
 
 8225              !ToPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
 
 8228            if (!Kind.isStaticCast()) {
 
 8230                     diag::warn_noderef_to_dereferenceable_pointer)
 
 8249      CurInit = CurInitExprRes;
 
 8270      InitListChecker PerformInitList(S, InitEntity,
 
 8271          InitList, Ty, 
false,
 
 8273      if (PerformInitList.HadError())
 
 8281        if ((*ResultType)->isRValueReferenceType())
 
 8283        else if ((*ResultType)->isLValueReferenceType())
 
 8290          PerformInitList.getFullyStructuredList();
 
 8293          : StructuredInitList;
 
 8310      assert(Args.size() == 1 && 
"expected a single argument for list init");
 
 8312      S.
Diag(InitList->
getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
 
 8318                                               ConstructorInitRequiresZeroInit,
 
 8356      bool IsStdInitListInit =
 
 8360                              ? Kind.getParenOrBraceRange()
 
 8363          S, UseTemporary ? TempEntity : Entity, Kind,
 
 8365          ConstructorInitRequiresZeroInit,
 
 8376      if (NextStep != StepEnd &&
 
 8381        ConstructorInitRequiresZeroInit = 
true;
 
 8384                 !Kind.isImplicitValueInit()) {
 
 8388                                                    Kind.getRange().getBegin());
 
 8392            Kind.getRange().getEnd());
 
 8427      CurInit = CurInitExprRes;
 
 8442          S.
Diag(Kind.getLocation(), diag::err_c23_constexpr_pointer_not_null);
 
 8456                                     InitialCurInit.
get(),
 
 8459        PrintInitLocationNote(S, Entity);
 
 8461      } 
else if (Complained)
 
 8462        PrintInitLocationNote(S, Entity);
 
 8478                          CK_ObjCObjectLValueCast,
 
 8490          BaseExpr, Kind.getLocation(), IndexExpr, Kind.getLocation());
 
 8491      ArrayLoopCommonExprs.push_back(BaseExpr);
 
 8496      assert(!ArrayLoopCommonExprs.empty() &&
 
 8497             "mismatched SK_ArrayLoopIndex and SK_ArrayLoopInit");
 
 8498      Expr *Common = ArrayLoopCommonExprs.pop_back_val();
 
 8507      S.
Diag(Kind.getLocation(), diag::ext_array_init_copy)
 
 8521                IncompleteDest->getElementType(), ConstantSource->getSize(),
 
 8531      S.
Diag(Kind.getLocation(), diag::ext_array_init_parens)
 
 8551             diag::warn_cxx98_compat_initializer_list_init)
 
 8564        [[maybe_unused]] 
bool IsStdInitializerList =
 
 8566        assert(IsStdInitializerList &&
 
 8567               "StdInitializerList step to non-std::initializer_list");
 
 8569        assert(
Record->isCompleteDefinition() &&
 
 8570               "std::initializer_list should have already be " 
 8571               "complete/instantiated by this point");
 
 8573        auto InvalidType = [&] {
 
 8575                 diag::err_std_initializer_list_malformed)
 
 8582          return InvalidType();
 
 8585        if (Field == 
Record->field_end())
 
 8586          return InvalidType();
 
 8589        if (!Field->getType()->isPointerType() ||
 
 8592          return InvalidType();
 
 8594        if (++Field == 
Record->field_end())
 
 8595          return InvalidType();
 
 8598        if (
const auto *PT = Field->getType()->getAs<
PointerType>()) {
 
 8601            return InvalidType();
 
 8603          if (Field->isBitField() ||
 
 8605            return InvalidType();
 
 8608        if (++Field != 
Record->field_end())
 
 8609          return InvalidType();
 
 8636             "Sampler initialization on non-sampler type.");
 
 8642          S.
Diag(Kind.getLocation(), diag::err_sampler_argument_required)
 
 8649          if (!Var->hasGlobalStorage()) {
 
 8664            Var->getInit()))->getSubExpr();
 
 8665          SourceType = 
Init->getType();
 
 8672        if (!
Init->isConstantInitializer(S.
Context, 
false))
 
 8677          S.
Diag(Kind.getLocation(), diag::err_sampler_initializer_not_integer)
 
 8685        const uint64_t SamplerValue = 
Result.getLimitedValue();
 
 8692        unsigned AddressingMode  = (0x0E & SamplerValue) >> 1;
 
 8693        unsigned FilterMode      = (0x30 & SamplerValue) >> 4;
 
 8694        if (FilterMode != 1 && FilterMode != 2 &&
 
 8696                "cl_intel_device_side_avc_motion_estimation", S.
getLangOpts()))
 
 8697          S.
Diag(Kind.getLocation(),
 
 8698                 diag::warn_sampler_initializer_invalid_bits)
 
 8700        if (AddressingMode > 4)
 
 8701          S.
Diag(Kind.getLocation(),
 
 8702                 diag::warn_sampler_initializer_invalid_bits)
 
 8703                 << 
"Addressing Mode";
 
 8709                                      CK_IntToOCLSampler);
 
 8715             "Wrong type for initialization of OpenCL opaque type.");
 
 8718                                    CK_ZeroToOCLOpaqueType,
 
 8726      if (CurInit.
get() && ResultType)
 
 8748    S.CheckBitFieldInitialization(Kind.getLocation(),
 
 
 8762  if (
T->isReferenceType()) {
 
 8763    S.
Diag(Loc, diag::err_reference_without_init)
 
 8764      << 
T.getNonReferenceType();
 
 8768  CXXRecordDecl *RD = 
T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
 
 8772  for (
const auto *FI : RD->
fields()) {
 
 8773    if (FI->isUnnamedBitField())
 
 8777      S.
Diag(Loc, diag::note_value_initialization_here) << RD;
 
 8782  for (
const auto &BI : RD->
bases()) {
 
 8784      S.
Diag(Loc, diag::note_value_initialization_here) << RD;
 
 
 8819  if (fromDecl && destDecl && fromDecl->getDeclKind() == Decl::CXXRecord &&
 
 8820      destDecl->getDeclKind() == Decl::CXXRecord &&
 
 8821      !fromDecl->isInvalidDecl() && !destDecl->isInvalidDecl() &&
 
 8822      !fromDecl->hasDefinition() &&
 
 8825    S.
Diag(fromDecl->getLocation(), diag::note_forward_class_conversion)
 
 
 8853    if (
auto *D = Entity.
getDecl())
 
 8854      Loc = D->getLocation();
 
 8855    S.
Diag(Loc, diag::note_in_reference_temporary_list_initializer) << 
T;
 
 8859  InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
 
 8862  assert(DiagnoseInitList.HadError() &&
 
 8863         "Inconsistent init list check result.");
 
 
 8878  if (Args.size() == 1) {
 
 8879    auto *List = dyn_cast<InitListExpr>(Args[0]);
 
 8880    if (List && List->getNumInits() == 1)
 
 8881      OnlyArg = List->getInit(0);
 
 8890        if (
Expr *Resolved =
 
 8910      assert(Diagnosed && 
"couldn't find uninitialized reference to diagnose");
 
 8913      S.
Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
 
 8914          << 
SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
 
 8917    S.
Diag(Kind.getLocation(), diag::err_list_init_in_parens)
 
 8918      << 1 << Entity.
getType() << Args[0]->getSourceRange();
 
 8922    S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
 
 8925    S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
 
 8928    S.
Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
 
 8931    S.
Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
 
 8934    S.
Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
 
 8937    S.
Diag(Kind.getLocation(),
 
 8938           diag::err_array_init_incompat_wide_string_into_wchar);
 
 8941    S.
Diag(Kind.getLocation(),
 
 8942           diag::err_array_init_plain_string_into_char8_t);
 
 8943    S.
Diag(Args.front()->getBeginLoc(),
 
 8944           diag::note_array_init_plain_string_into_char8_t)
 
 8948    S.
Diag(Kind.getLocation(), diag::err_array_init_utf8_string_into_char)
 
 8953    S.
Diag(Kind.getLocation(),
 
 8955              ? diag::err_array_init_different_type
 
 8956              : diag::err_array_init_non_constant_array))
 
 8959      << Args[0]->getSourceRange();
 
 8963    S.
Diag(Kind.getLocation(), diag::err_variable_object_no_init)
 
 8964      << Args[0]->getSourceRange();
 
 8985    switch (FailedOverloadResult) {
 
 8988      FailedCandidateSet.NoteCandidates(
 
 8992                  ? (S.
PDiag(diag::err_typecheck_ambiguous_condition)
 
 8993                     << OnlyArg->
getType() << DestType
 
 8994                     << Args[0]->getSourceRange())
 
 8995                  : (S.
PDiag(diag::err_ref_init_ambiguous)
 
 8996                     << DestType << OnlyArg->
getType()
 
 8997                     << Args[0]->getSourceRange())),
 
 9005                          diag::err_typecheck_nonviable_condition_incomplete,
 
 9006                               OnlyArg->
getType(), Args[0]->getSourceRange()))
 
 9007        S.
Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
 
 9009          << OnlyArg->
getType() << Args[0]->getSourceRange()
 
 9012      FailedCandidateSet.NoteCandidates(S, Args, Cands);
 
 9018        = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
 
 9021      S.
Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
 
 9023          << (Msg != 
nullptr) << (Msg ? Msg->
getString() : StringRef())
 
 9024          << Args[0]->getSourceRange();
 
 9028        llvm_unreachable(
"Inconsistent overload resolution?");
 
 9034      llvm_unreachable(
"Conversion did not fail!");
 
 9040      S.
Diag(Kind.getLocation(),
 
 9041             diag::err_lvalue_reference_bind_to_initlist)
 
 9044      << Args[0]->getSourceRange();
 
 9050    S.
Diag(Kind.getLocation(),
 
 9052             ? diag::err_lvalue_reference_bind_to_temporary
 
 9053             : diag::err_lvalue_reference_bind_to_unrelated)
 
 9057      << Args[0]->getSourceRange();
 
 9062    FieldDecl *BitField = Args[0]->getSourceBitField();
 
 9063    S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
 
 9066      << (BitField != 
nullptr)
 
 9067      << Args[0]->getSourceRange();
 
 9074    S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
 
 9076      << Args[0]->getSourceRange();
 
 9080    S.
Diag(Kind.getLocation(), diag::err_reference_bind_to_matrix_element)
 
 9085    S.
Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
 
 9087      << Args[0]->getSourceRange();
 
 9091    S.
Diag(Kind.getLocation(), diag::err_reference_bind_temporary_addrspace)
 
 9092        << DestType << Args[0]->getSourceRange();
 
 9103      S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
 
 9104          << NonRefType << SourceType << 1 
 
 9105          << Args[0]->getSourceRange();
 
 9107      S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
 
 9108          << NonRefType << SourceType << 0 
 
 9114      S.
Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
 
 9115          << NonRefType << SourceType << 2 
 
 9116          << Args[0]->getSourceRange();
 
 9121    S.
Diag(Kind.getLocation(), diag::err_reference_bind_failed)
 
 9126      << Args[0]->getSourceRange();
 
 9137      << Args[0]->getSourceRange();
 
 9139    S.
Diag(Kind.getLocation(), PDiag);
 
 9151    auto *InitList = dyn_cast<InitListExpr>(Args[0]);
 
 9152    if (InitList && InitList->getNumInits() >= 1) {
 
 9153      R = 
SourceRange(InitList->getInit(0)->getEndLoc(), InitList->getEndLoc());
 
 9155      assert(Args.size() > 1 && 
"Expected multiple initializers!");
 
 9156      R = 
SourceRange(Args.front()->getEndLoc(), Args.back()->getEndLoc());
 
 9160    if (Kind.isCStyleOrFunctionalCast())
 
 9161      S.
Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
 
 9164      S.
Diag(Kind.getLocation(), diag::err_excess_initializers)
 
 9170    S.
Diag(Kind.getLocation(), diag::err_list_init_in_parens)
 
 9171      << 0 << Entity.
getType() << Args[0]->getSourceRange();
 
 9175    S.
Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
 
 9180    S.
Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
 
 9181      << (DestType->
isRecordType()) << DestType << Args[0]->getSourceRange();
 
 9189          SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());
 
 9192      assert(Args.size() == 1 &&
 
 9193             "List construction from other than 1 argument.");
 
 9200    switch (FailedOverloadResult) {
 
 9202        FailedCandidateSet.NoteCandidates(
 
 9204                                S.
PDiag(diag::err_ovl_ambiguous_init)
 
 9205                                    << DestType << ArgsRange),
 
 9222          if (
auto Inherited = 
Constructor->getInheritedConstructor())
 
 9223            InheritedFrom = Inherited.getShadowDecl()->getNominatedBaseClass();
 
 9225            S.
Diag(Kind.getLocation(), diag::err_missing_default_ctor)
 
 9226                << (InheritedFrom               ? 2
 
 9230                << 0 << Entity.
getType() << InheritedFrom;
 
 9234            S.
Diag(BaseDecl->getLocation(), diag::note_previous_decl)
 
 9237            S.
Diag(Kind.getLocation(), diag::err_missing_default_ctor)
 
 9238                << (InheritedFrom               ? 2
 
 9242                << 1 << Entity.
getName() << InheritedFrom;
 
 9244                   diag::note_member_declared_at);
 
 9247              S.
Diag(
Record->getDecl()->getLocation(), diag::note_previous_decl)
 
 9253        FailedCandidateSet.NoteCandidates(
 
 9256                S.
PDiag(diag::err_ovl_no_viable_function_in_init)
 
 9257                    << DestType << ArgsRange),
 
 9264          = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
 
 9266          S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
 
 9267              << DestType << ArgsRange;
 
 9268          llvm_unreachable(
"Inconsistent overload resolution?");
 
 9276          S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
 
 9278              << DestType << ArgsRange;
 
 9281          S.
Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
 
 9282              << DestType << (Msg != 
nullptr)
 
 9283              << (Msg ? Msg->
getString() : StringRef()) << ArgsRange;
 
 9294                 diag::note_default_constructed_field)
 
 9302        llvm_unreachable(
"Conversion did not fail!");
 
 9314      S.
Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
 
 9322    } 
else if (
const auto *VD = dyn_cast_if_present<VarDecl>(Entity.
getDecl());
 
 9323               VD && VD->isConstexpr()) {
 
 9324      S.
Diag(Kind.getLocation(), diag::err_constexpr_var_requires_const_init)
 
 9327      S.
Diag(Kind.getLocation(), diag::err_default_init_const)
 
 9334                          diag::err_init_incomplete_type);
 
 9358    S.
Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
 
 9359      << Args[0]->getSourceRange();
 
 9362      = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
 
 9364    assert(Ovl == 
OR_Success && 
"Inconsistent overload resolution");
 
 9367           diag::note_explicit_ctor_deduction_guide_here) << 
false;
 
 9378    S.
Diag(Kind.getLocation(), diag::err_designated_init_for_non_aggregate)
 
 9383  PrintInitLocationNote(S, Entity);
 
 
 9390    OS << 
"Failed sequence: ";
 
 9393      OS << 
"too many initializers for reference";
 
 9397      OS << 
"parenthesized list init for reference";
 
 9401      OS << 
"array requires initializer list";
 
 9405      OS << 
"address of unaddressable function was taken";
 
 9409      OS << 
"array requires initializer list or string literal";
 
 9413      OS << 
"array requires initializer list or wide string literal";
 
 9417      OS << 
"narrow string into wide char array";
 
 9421      OS << 
"wide string into char array";
 
 9425      OS << 
"incompatible wide string into wide char array";
 
 9429      OS << 
"plain string literal into char8_t array";
 
 9433      OS << 
"u8 string literal into char array";
 
 9437      OS << 
"array type mismatch";
 
 9441      OS << 
"non-constant array initializer";
 
 9445      OS << 
"address of overloaded function failed";
 
 9449      OS << 
"overload resolution for reference initialization failed";
 
 9453      OS << 
"non-const lvalue reference bound to temporary";
 
 9457      OS << 
"non-const lvalue reference bound to bit-field";
 
 9461      OS << 
"non-const lvalue reference bound to vector element";
 
 9465      OS << 
"non-const lvalue reference bound to matrix element";
 
 9469      OS << 
"non-const lvalue reference bound to unrelated type";
 
 9473      OS << 
"rvalue reference bound to an lvalue";
 
 9477      OS << 
"reference initialization drops qualifiers";
 
 9481      OS << 
"reference with mismatching address space bound to temporary";
 
 9485      OS << 
"reference initialization failed";
 
 9489      OS << 
"conversion failed";
 
 9493      OS << 
"conversion from property failed";
 
 9497      OS << 
"too many initializers for scalar";
 
 9501      OS << 
"parenthesized list init for reference";
 
 9505      OS << 
"referencing binding to initializer list";
 
 9509      OS << 
"initializer list for non-aggregate, non-scalar type";
 
 9513      OS << 
"overloading failed for user-defined conversion";
 
 9517      OS << 
"constructor overloading failed";
 
 9521      OS << 
"default initialization of a const variable";
 
 9525      OS << 
"initialization of incomplete type";
 
 9529      OS << 
"list initialization checker failure";
 
 9533      OS << 
"variable length array has an initializer";
 
 9537      OS << 
"initializer expression isn't contextually valid";
 
 9541      OS << 
"list constructor overloading failed";
 
 9545      OS << 
"list copy initialization chose explicit constructor";
 
 9549      OS << 
"parenthesized list initialization failed";
 
 9553      OS << 
"designated initializer for non-aggregate type";
 
 9557      OS << 
"HLSL initialization list flattening failed";
 
 9565    OS << 
"Dependent sequence\n";
 
 9569    OS << 
"Normal sequence: ";
 
 9580      OS << 
"resolve address of overloaded function";
 
 9584      OS << 
"derived-to-base (prvalue)";
 
 9588      OS << 
"derived-to-base (xvalue)";
 
 9592      OS << 
"derived-to-base (lvalue)";
 
 9596      OS << 
"bind reference to lvalue";
 
 9600      OS << 
"bind reference to a temporary";
 
 9604      OS << 
"final copy in class direct-initialization";
 
 9608      OS << 
"extraneous C++03 copy to temporary";
 
 9612      OS << 
"user-defined conversion via " << *S->Function.Function;
 
 9616      OS << 
"qualification conversion (prvalue)";
 
 9620      OS << 
"qualification conversion (xvalue)";
 
 9624      OS << 
"qualification conversion (lvalue)";
 
 9628      OS << 
"function reference conversion";
 
 9632      OS << 
"non-atomic-to-atomic conversion";
 
 9636      OS << 
"implicit conversion sequence (";
 
 9642      OS << 
"implicit conversion sequence with narrowing prohibited (";
 
 9648      OS << 
"list aggregate initialization";
 
 9652      OS << 
"unwrap reference initializer list";
 
 9656      OS << 
"rewrap reference initializer list";
 
 9660      OS << 
"constructor initialization";
 
 9664      OS << 
"list initialization via constructor";
 
 9668      OS << 
"zero initialization";
 
 9672      OS << 
"C assignment";
 
 9676      OS << 
"string initialization";
 
 9680      OS << 
"Objective-C object conversion";
 
 9684      OS << 
"indexing for array initialization loop";
 
 9688      OS << 
"array initialization loop";
 
 9692      OS << 
"array initialization";
 
 9696      OS << 
"array initialization (GNU extension)";
 
 9700      OS << 
"parenthesized array initialization";
 
 9704      OS << 
"pass by indirect copy and restore";
 
 9708      OS << 
"pass by indirect restore";
 
 9712      OS << 
"Objective-C object retension";
 
 9716      OS << 
"std::initializer_list from initializer list";
 
 9720      OS << 
"list initialization from std::initializer_list";
 
 9724      OS << 
"OpenCL sampler_t from integer constant";
 
 9728      OS << 
"OpenCL opaque type from zero";
 
 9731      OS << 
"initialization from a parenthesized list of values";
 
 9735    OS << 
" [" << S->Type << 
']';
 
 
 9749                                        const Expr *PostInit) {
 
 9765  auto MakeDiag = [&](
bool IsConstRef, 
unsigned DefaultDiagID,
 
 9766                      unsigned ConstRefDiagID, 
unsigned WarnDiagID) {
 
 9769    if (L.CPlusPlus11 && !L.HLSL &&
 
 9771      DiagID = IsConstRef ? ConstRefDiagID : DefaultDiagID;
 
 9773      DiagID = WarnDiagID;
 
 9793    MakeDiag(
T != EntityType, diag::ext_init_list_type_narrowing,
 
 9794             diag::ext_init_list_type_narrowing_const_reference,
 
 9795             diag::warn_init_list_type_narrowing)
 
 9797        << 
T.getLocalUnqualifiedType();
 
 9804             diag::ext_init_list_constant_narrowing,
 
 9805             diag::ext_init_list_constant_narrowing_const_reference,
 
 9806             diag::warn_init_list_constant_narrowing)
 
 9815             diag::ext_init_list_variable_narrowing,
 
 9816             diag::ext_init_list_variable_narrowing_const_reference,
 
 9817             diag::warn_init_list_variable_narrowing)
 
 9825  llvm::raw_svector_ostream OS(StaticCast);
 
 9826  OS << 
"static_cast<";
 
 9833    OS << *TT->getDecl();
 
 9842  S.
Diag(PostInit->
getBeginLoc(), diag::note_init_list_narrowing_silence)
 
 
 9853      Init->IgnoreParenImpCasts(), ToType,  
false,
 
 9854      Sema::AllowedExplicit::None,
 
 9870    S.
Diag(
Init->getBeginLoc(), diag::err_c23_constexpr_init_not_representable)
 
 9871        << 
Value.getAsString(S.
Context, PreNarrowingType) << ToType;
 
 9876    S.
Diag(
Init->getBeginLoc(), diag::err_c23_constexpr_init_type_mismatch)
 
 9877        << ToType << FromType;
 
 9887  llvm_unreachable(
"unhandled case in switch");
 
 
 9899  for (
unsigned I = 0, N = SE->
getLength(); I != N; ++I) {
 
 9904                   diag::err_c23_constexpr_init_not_representable)
 
 
 9917  if (
Init.isInvalid())
 
 9921  assert(InitE && 
"No initialization expression");
 
 9926  return !
Seq.Failed();
 
 
 9933                                bool TopLevelOfInitList,
 
 9934                                bool AllowExplicit) {
 
 9935  if (
Init.isInvalid())
 
 9939  assert(InitE && 
"No initialization expression?");
 
 9949  const bool ShouldTrackCopy =
 
 9951  if (ShouldTrackCopy) {
 
 9953      Seq.SetOverloadFailure(
 
 9959      const auto LastStep = 
Seq.step_end() - 1;
 
 9960      assert(LastStep->Kind ==
 
 9964          llvm::find_if(
Seq.getFailedCandidateSet(),
 
 9966                          return Candidate.Viable &&
 
 9967                                 Candidate.Function == Function &&
 
 9968                                 Candidate.Conversions.size() > 0;
 
 9970      if (Candidate != 
Seq.getFailedCandidateSet().end() &&
 
 9972        Candidate->
Viable = 
false;
 
 9976                                         Function->getParamDecl(0)->getType());
 
 9984  if (ShouldTrackCopy)
 
 
 9993  auto NotSpecialization = [&] (
const CXXRecordDecl *Candidate) {
 
 9994    auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Candidate);
 
 9997  return !(NotSpecialization(RD) && RD->
forallBases(NotSpecialization));
 
 
10003  auto *DeducedTST = dyn_cast<DeducedTemplateSpecializationType>(
 
10005  assert(DeducedTST && 
"not a deduced template specialization type");
 
10016    if (
auto *
AliasTemplate = dyn_cast_or_null<TypeAliasTemplateDecl>(
 
10018      DiagCompat(Kind.getLocation(), diag_compat::ctad_for_alias_templates);
 
10021                                ->getUnderlyingType()
 
10022                                .getCanonicalType();
 
10026      if (
const auto *TST =
 
10027              UnderlyingType->getAs<TemplateSpecializationType>()) {
 
10028        Template = dyn_cast_or_null<ClassTemplateDecl>(
 
10029            TST->getTemplateName().getAsTemplateDecl());
 
10030      } 
else if (
const auto *RT = UnderlyingType->getAs<RecordType>()) {
 
10034        if (
const auto *CTSD =
 
10035                llvm::dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl()))
 
10036          Template = CTSD->getSpecializedTemplate();
 
10041    Diag(Kind.getLocation(),
 
10042         diag::err_deduced_non_class_or_alias_template_specialization_type)
 
10052         diag::warn_cxx14_compat_class_template_argument_deduction)
 
10068      Context.DeclarationNames.getCXXDeductionGuideName(LookupTemplateDecl),
 
10080          ? dyn_cast<InitListExpr>(Inits[0])
 
10096  bool AllowExplicit = !Kind.isCopyInit() || 
ListInit;
 
10102                                   bool OnlyListConstructors,
 
10103                                   bool AllowAggregateDeductionCandidate) {
 
10109    if (!AllowExplicit) {
 
10116      if (GD->getMinRequiredArguments() > 1 ||
 
10117          (GD->getNumParams() == 0 && !GD->isVariadic()))
 
10127    if (!AllowAggregateDeductionCandidate &&
 
10147      for (
auto [I, E] : llvm::enumerate(Inits)) {
 
10148        if (
auto *DI = dyn_cast<DesignatedInitExpr>(E))
 
10149          TmpInits[I] = DI->getInit();
 
10155          TD, FoundDecl, 
nullptr, TmpInits, Candidates,
 
10157          false, AllowExplicit, ADLCallKind::NotADL,
 
10158          {}, AllowAggregateDeductionCandidate);
 
10162                           false, AllowExplicit);
 
10166  bool FoundDeductionGuide = 
false;
 
10168  auto TryToResolveOverload =
 
10171    bool HasAnyDeductionGuide = 
false;
 
10175      while (Pattern->getInstantiatedFromMemberTemplate()) {
 
10176        if (Pattern->isMemberSpecialization())
 
10178        Pattern = Pattern->getInstantiatedFromMemberTemplate();
 
10187      InitListChecker CheckInitList(*
this, Entity, 
ListInit, Ty, ElementTypes);
 
10188      if (!CheckInitList.HadError()) {
 
10197        for (
int I = 0, E = 
ListInit->getNumInits();
 
10199          if (ElementTypes[I]->isArrayType()) {
 
10201              ElementTypes[I] = 
Context.getRValueReferenceType(ElementTypes[I]);
 
10203                         ListInit->getInit(I)->IgnoreParenImpCasts()))
 
10205                  Context.getLValueReferenceType(ElementTypes[I].withConst());
 
10210                    LookupTemplateDecl, ElementTypes,
 
10214                                OnlyListConstructors,
 
10216          HasAnyDeductionGuide = 
true;
 
10221    for (
auto I = Guides.
begin(), E = Guides.
end(); I != E; ++I) {
 
10222      NamedDecl *D = (*I)->getUnderlyingDecl();
 
10226      auto *TD = dyn_cast<FunctionTemplateDecl>(D);
 
10227      auto *GD = dyn_cast_if_present<CXXDeductionGuideDecl>(
 
10232      if (!GD->isImplicit())
 
10233        HasAnyDeductionGuide = 
true;
 
10235      addDeductionCandidate(TD, GD, I.getPair(), OnlyListConstructors,
 
10250      } 
else if (Inits.size()) { 
 
10255                                  Inits, Inits.back()->getEndLoc());
 
10256        SynthesizeAggrGuide(&TempListInit);
 
10260    FoundDeductionGuide = FoundDeductionGuide || HasAnyDeductionGuide;
 
10270    bool TryListConstructors = 
true;
 
10276        auto *FD = dyn_cast<FunctionDecl>(D->getUnderlyingDecl());
 
10277        if (FD && FD->getMinRequiredArguments() == 0) {
 
10278          TryListConstructors = 
false;
 
10282    } 
else if (
ListInit->getNumInits() == 1) {
 
10293        TryListConstructors = 
false;
 
10296    if (TryListConstructors)
 
10297      Result = TryToResolveOverload(
true);
 
10306    Result = TryToResolveOverload(
false);
 
10315            Kind.getLocation(),
 
10316            PDiag(diag::err_deduced_class_template_ctor_ambiguous)
 
10325                                   Context.getCanonicalTagType(Primary));
 
10328            Kind.getLocation(),
 
10329            PDiag(
Complete ? diag::err_deduced_class_template_ctor_no_viable
 
10330                           : diag::err_deduced_class_template_incomplete)
 
10340    Diag(Kind.getLocation(), diag::err_deduced_class_template_deleted)
 
10350    if (Kind.isCopyInit() && 
ListInit &&
 
10352      bool IsDeductionGuide = !Best->Function->isImplicit();
 
10353      Diag(Kind.getLocation(), diag::err_deduced_class_template_explicit)
 
10355      Diag(Best->Function->getLocation(),
 
10356           diag::note_explicit_ctor_deduction_guide_here)
 
10357          << IsDeductionGuide;
 
10375       diag::warn_cxx14_compat_class_template_argument_deduction)
 
10380  if (!FoundDeductionGuide) {
 
10382         diag::warn_ctad_maybe_unsupported)
 
10384    Diag(
Template->getLocation(), diag::note_suppress_ctad_maybe_unsupported);
 
10387  return DeducedType;
 
 
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
Defines the clang::Preprocessor interface.
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)
This file declares semantic analysis for HLSL constructs.
static bool isExprAnUnaddressableFunction(Sema &S, const Expr *E)
Tries to get a FunctionDecl out of E.
static void updateStringLiteralType(Expr *E, QualType Ty)
Update the type of a string literal, including any surrounding parentheses, to match the type of the ...
static void updateGNUCompoundLiteralRValue(Expr *E)
Fix a compound literal initializing an array so it's correctly marked as an rvalue.
static bool initializingConstexprVariable(const InitializedEntity &Entity)
static void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity, SourceRange Braces)
Warn that Entity was of scalar type and was initialized by a single-element braced initializer list.
static bool shouldDestroyEntity(const InitializedEntity &Entity)
Whether the given entity, when initialized with an object created for that initialization,...
static SourceLocation getInitializationLoc(const InitializedEntity &Entity, Expr *Initializer)
Get the location at which initialization diagnostics should appear.
static bool hasAnyDesignatedInits(const InitListExpr *IL)
static bool tryObjCWritebackConversion(Sema &S, InitializationSequence &Sequence, const InitializedEntity &Entity, Expr *Initializer)
static DesignatedInitExpr * CloneDesignatedInitExpr(Sema &SemaRef, DesignatedInitExpr *DIE)
static ExprResult CopyObject(Sema &S, QualType T, const InitializedEntity &Entity, ExprResult CurInit, bool IsExtraneousCopy)
Make a (potentially elidable) temporary copy of the object provided by the given initializer by calli...
static void TryOrBuildParenListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr * > Args, InitializationSequence &Sequence, bool VerifyOnly, ExprResult *Result=nullptr)
static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT, Sema &S, const InitializedEntity &Entity, bool CheckC23ConstexprInit=false)
static void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr, bool IsReturnStmt)
Provide warnings when std::move is used on construction.
static void CheckC23ConstexprInitStringLiteral(const StringLiteral *SE, Sema &SemaRef, QualType &TT)
static void CheckCXX98CompatAccessibleCopy(Sema &S, const InitializedEntity &Entity, Expr *CurInitExpr)
Check whether elidable copy construction for binding a reference to a temporary would have succeeded ...
static bool isOrIsDerivedFromSpecializationOf(CXXRecordDecl *RD, ClassTemplateDecl *CTD)
Determine whether RD is, or is derived from, a specialization of CTD.
static bool canInitializeArrayWithEmbedDataString(ArrayRef< Expr * > ExprList, const InitializedEntity &Entity, ASTContext &Context)
static bool TryInitializerListConstruction(Sema &S, InitListExpr *List, QualType DestType, InitializationSequence &Sequence, bool TreatUnavailableAsInvalid)
When initializing from init list via constructor, handle initialization of an object of type std::ini...
static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT, ASTContext &Context)
Check whether the array of type AT can be initialized by the Init expression by means of string initi...
static void TryArrayCopy(Sema &S, const InitializationKind &Kind, const InitializedEntity &Entity, Expr *Initializer, QualType DestType, InitializationSequence &Sequence, bool TreatUnavailableAsInvalid)
Initialize an array from another array.
static bool isInitializedStructuredList(const InitListExpr *StructuredList)
@ SIF_PlainStringIntoUTF8Char
@ SIF_IncompatWideStringIntoWideChar
@ SIF_UTF8StringIntoPlainChar
@ SIF_NarrowStringIntoWideChar
static void TryDefaultInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitializationSequence &Sequence)
Attempt default initialization (C++ [dcl.init]p6).
static bool TryOCLSamplerInitialization(Sema &S, InitializationSequence &Sequence, QualType DestType, Expr *Initializer)
static bool maybeRecoverWithZeroInitialization(Sema &S, InitializationSequence &Sequence, const InitializedEntity &Entity)
Tries to add a zero initializer. Returns true if that worked.
static ExprResult CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value)
Check that the given Index expression is a valid array designator value.
static bool canPerformArrayCopy(const InitializedEntity &Entity)
Determine whether we can perform an elementwise array copy for this kind of entity.
static void TryReferenceInitializationCore(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, QualType cv1T1, QualType T1, Qualifiers T1Quals, QualType cv2T2, QualType T2, Qualifiers T2Quals, InitializationSequence &Sequence, bool TopLevelOfInitList)
Reference initialization without resolving overloaded functions.
static void CheckC23ConstexprInitConversion(Sema &S, QualType FromType, QualType ToType, Expr *Init)
static void ExpandAnonymousFieldDesignator(Sema &SemaRef, DesignatedInitExpr *DIE, unsigned DesigIdx, IndirectFieldDecl *IndirectField)
Expand a field designator that refers to a member of an anonymous struct or union into a series of fi...
static void TryValueInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitializationSequence &Sequence, InitListExpr *InitList=nullptr)
Attempt value initialization (C++ [dcl.init]p7).
static void TryUserDefinedConversion(Sema &S, QualType DestType, const InitializationKind &Kind, Expr *Initializer, InitializationSequence &Sequence, bool TopLevelOfInitList)
Attempt a user-defined conversion between two types (C++ [dcl.init]), which enumerates all conversion...
static OverloadingResult ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc, MultiExprArg Args, OverloadCandidateSet &CandidateSet, QualType DestType, DeclContext::lookup_result Ctors, OverloadCandidateSet::iterator &Best, bool CopyInitializing, bool AllowExplicit, bool OnlyListConstructors, bool IsListInit, bool RequireActualConstructor, bool SecondStepOfCopyInit=false)
static AssignmentAction getAssignmentAction(const InitializedEntity &Entity, bool Diagnose=false)
static void TryListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitListExpr *InitList, InitializationSequence &Sequence, bool TreatUnavailableAsInvalid)
Attempt list initialization (C++0x [dcl.init.list])
static void TryStringLiteralInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, InitializationSequence &Sequence)
Attempt character array initialization from a string literal (C++ [dcl.init.string],...
static bool checkDestructorReference(QualType ElementType, SourceLocation Loc, Sema &SemaRef)
Check if the type of a class element has an accessible destructor, and marks it referenced.
static void TryReferenceInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, InitializationSequence &Sequence, bool TopLevelOfInitList)
Attempt reference initialization (C++0x [dcl.init.ref])
static void DiagnoseNarrowingInInitList(Sema &S, const ImplicitConversionSequence &ICS, QualType PreNarrowingType, QualType EntityType, const Expr *PostInit)
static bool hasCompatibleArrayTypes(ASTContext &Context, const ArrayType *Dest, const ArrayType *Source)
Determine whether we have compatible array types for the purposes of GNU by-copy array initialization...
static bool isExplicitTemporary(const InitializedEntity &Entity, const InitializationKind &Kind, unsigned NumArgs)
Returns true if the parameters describe a constructor initialization of an explicit temporary object,...
static bool isNonReferenceableGLValue(Expr *E)
Determine whether an expression is a non-referenceable glvalue (one to which a reference can never bi...
static bool TryOCLZeroOpaqueTypeInitialization(Sema &S, InitializationSequence &Sequence, QualType DestType, Expr *Initializer)
static bool IsWideCharCompatible(QualType T, ASTContext &Context)
Check whether T is compatible with a wide character type (wchar_t, char16_t or char32_t).
static void diagnoseListInit(Sema &S, const InitializedEntity &Entity, InitListExpr *InitList)
static OverloadingResult TryRefInitWithConversionFunction(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, bool AllowRValues, bool IsLValueRef, InitializationSequence &Sequence)
Try a reference initialization that involves calling a conversion function.
void emitUninitializedExplicitInitFields(Sema &S, const RecordDecl *R)
static void TryConstructorInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType DestType, QualType DestArrayType, InitializationSequence &Sequence, bool IsListInit=false, bool IsInitListCopy=false)
Attempt initialization by constructor (C++ [dcl.init]), which enumerates the constructors of the init...
static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity, Expr *op)
Emit notes associated with an initialization that failed due to a "simple" conversion failure.
static bool isIdiomaticBraceElisionEntity(const InitializedEntity &Entity)
Determine whether Entity is an entity for which it is idiomatic to elide the braces in aggregate init...
static void MaybeProduceObjCObject(Sema &S, InitializationSequence &Sequence, const InitializedEntity &Entity)
static void checkIndirectCopyRestoreSource(Sema &S, Expr *src)
Check whether the given expression is a valid operand for an indirect copy/restore.
static bool shouldBindAsTemporary(const InitializedEntity &Entity)
Whether we should bind a created object as a temporary when initializing the given entity.
static void TryConstructorOrParenListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType DestType, InitializationSequence &Sequence, bool IsAggrListInit)
Attempt to initialize an object of a class type either by direct-initialization, or by copy-initializ...
static bool IsZeroInitializer(const Expr *Init, ASTContext &Ctx)
static const FieldDecl * getConstField(const RecordDecl *RD)
static bool ResolveOverloadedFunctionForReferenceBinding(Sema &S, Expr *Initializer, QualType &SourceType, QualType &UnqualifiedSourceType, QualType UnqualifiedTargetType, InitializationSequence &Sequence)
InvalidICRKind
The non-zero enum values here are indexes into diagnostic alternatives.
static ExprResult PerformConstructorInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, const InitializationSequence::Step &Step, bool &ConstructorInitRequiresZeroInit, bool IsListInitialization, bool IsStdInitListInitialization, SourceLocation LBraceLoc, SourceLocation RBraceLoc)
static void TryReferenceListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitListExpr *InitList, InitializationSequence &Sequence, bool TreatUnavailableAsInvalid)
Attempt list initialization of a reference.
static bool hasCopyOrMoveCtorParam(ASTContext &Ctx, const ConstructorInfo &Info)
Determine if the constructor has the signature of a copy or move constructor for the type T of the cl...
static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc, QualType T)
Somewhere within T there is an uninitialized reference subobject.
static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e, bool isAddressOf, bool &isWeakAccess)
Determines whether this expression is an acceptable ICR source.
This file declares semantic analysis for Objective-C.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
C Language Family Type Representation.
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
static CanQualType getCanonicalType(QualType T)
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
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 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 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,...
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
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 getPackExpansionType(QualType Pattern, UnsignedOrNone NumExpansions, bool ExpectPackInType=true) const
Form a pack expansion type with the given pattern.
static bool hasSameType(QualType T1, QualType T2)
Determine whether the given types T1 and T2 are equivalent.
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 getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
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
CanQualType getCanonicalTagType(const TagDecl *TD) const
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
static bool hasSameUnqualifiedType(QualType T1, QualType T2)
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Represents a loop initializing the elements of an array.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
This class is used for builtin types like 'int'.
Represents a base class of a C++ class.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
QualType getType() const
Retrieves the type of the base class.
Represents a call to a C++ constructor.
Expr * getArg(unsigned Arg)
Return the specified argument.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Represents a C++ constructor within a class.
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isExplicit() const
Return true if the declaration is already resolved to be explicit.
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Represents a C++ conversion function within a class.
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a C++ deduction guide declaration.
Represents a C++ destructor within a class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
static CXXParenListInitExpr * Create(ASTContext &C, ArrayRef< Expr * > Args, QualType T, unsigned NumUserSpecifiedExprs, SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Represents a C++ struct/union/class.
bool hasUninitializedReferenceMember() const
Whether this class or any of its subobjects has any members of reference type which would make value-...
bool allowConstDefaultInit() const
Determine whether declaring a const variable with this type is ok per core issue 253.
CXXBaseSpecifier * base_class_iterator
Iterator that traverses the base classes of a class.
llvm::iterator_range< base_class_const_iterator > base_class_const_range
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.
const CXXBaseSpecifier * base_class_const_iterator
Iterator that traverses the base classes of a class.
llvm::iterator_range< base_class_iterator > base_class_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 an rvalue of a non-class type T.
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
bool isCallToStdMove() const
SourceLocation getRParenLoc() const
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)
ConditionalOperator - The ?
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.
unsigned getNumElementsFlattened() const
Returns the number of elements required to embed the matrix into a vector.
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
NamedDecl * getDecl() const
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
DeclContextLookupResult lookup_result
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
A reference to a declared variable, function, enum, etc.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Decl - This represents one declaration (or definition), e.g.
SourceLocation getEndLoc() const LLVM_READONLY
static bool isFlexibleArrayMemberLike(const ASTContext &Context, const Decl *D, QualType Ty, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution)
Whether it resembles a flexible array member.
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
void setReferenced(bool R=true)
DeclContext * getDeclContext()
SourceLocation getBeginLoc() const LLVM_READONLY
The name of a declaration.
SourceLocation getBeginLoc() const LLVM_READONLY
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
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).
MutableArrayRef< Designator > designators()
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,...
static DesignatedInitExpr * Create(const ASTContext &C, ArrayRef< Designator > Designators, ArrayRef< Expr * > IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)
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.
Represents a reference to emded data.
StringLiteral * getDataStringLiteral() const
EmbedDataStorage * getData() const
SourceLocation getLocation() const
size_t getDataElementCount() const
RAII object that enters a new expression evaluation context.
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
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) 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.
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.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
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...
unsigned getNumInitsWithEmbedExpanded() const
getNumInits but if the list has an EmbedExpr inside includes full length of embedded data.
SourceLocation getRBraceLoc() const
const Expr * getInit(unsigned Init) const
bool isIdiomaticZeroInitializer(const LangOptions &LangOpts) const
Is this the zero initializer {0} in a language which considers it idiomatic?
SourceLocation getEndLoc() const LLVM_READONLY
void setInitializedFieldInUnion(FieldDecl *FD)
bool isSyntacticForm() const
ArrayRef< Expr * > inits()
void setRBraceLoc(SourceLocation Loc)
void sawArrayRangeDesignator(bool ARD=true)
Expr ** getInits()
Retrieve the set of initializers.
Describes the kind of initialization being performed, along with location information for tokens rela...
@ IK_DirectList
Direct list-initialization.
@ IK_Value
Value initialization.
@ IK_Direct
Direct initialization.
@ IK_Copy
Copy initialization.
@ IK_Default
Default initialization.
InitKind getKind() const
Determine the initialization kind.
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 AddUnwrapInitListInitStep(InitListExpr *Syntactic)
Only used when initializing structured bindings from an array with direct-list-initialization.
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...
OverloadingResult getFailedOverloadResult() const
Get the overloading result, for when the initialization sequence failed due to a bad overload.
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_HLSLInitListFlatteningFailed
HLSL intialization list flattening failed.
@ FK_PlaceholderType
Initializer has a placeholder type which cannot be resolved by initialization.
@ FK_IncompatWideStringIntoWideChar
Initializing wide char array with incompatible wide string literal.
@ FK_NonConstLValueReferenceBindingToMatrixElement
Non-const lvalue reference binding to a matrix element.
@ FK_TooManyInitsForReference
Too many initializers provided for a reference.
@ FK_NonConstLValueReferenceBindingToBitfield
Non-const lvalue reference binding to a bit-field.
@ FK_ReferenceAddrspaceMismatchTemporary
Reference with mismatching address space binding to temporary.
@ FK_ListInitializationFailed
List initialization failed at some point.
@ FK_TooManyInitsForScalar
Too many initializers for scalar.
@ FK_AddressOfOverloadFailed
Cannot resolve the address of an overloaded function.
@ FK_VariableLengthArrayHasInitializer
Variable-length array must not have an initializer.
@ FK_ArrayNeedsInitListOrWideStringLiteral
Array must be initialized with an initializer list or a wide string literal.
@ FK_RValueReferenceBindingToLValue
Rvalue reference binding to an lvalue.
@ FK_Incomplete
Initialization of an incomplete type.
@ FK_WideStringIntoCharArray
Initializing char array with wide string literal.
@ FK_ExplicitConstructor
List-copy-initialization chose an explicit constructor.
@ FK_ReferenceInitOverloadFailed
Overloading due to reference initialization failed.
@ FK_ConstructorOverloadFailed
Overloading for initialization by constructor failed.
@ FK_ReferenceBindingToInitList
Reference initialization from an initializer list.
@ FK_DefaultInitOfConst
Default-initialization of a 'const' object.
@ FK_ParenthesizedListInitFailed
Parenthesized list initialization failed at some point.
@ FK_AddressOfUnaddressableFunction
Trying to take the address of a function that doesn't support having its address taken.
@ FK_UTF8StringIntoPlainChar
Initializing char array with UTF-8 string literal.
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init....
void AddArrayInitLoopStep(QualType T, QualType EltTy)
Add an array initialization loop step.
void AddAddressOverloadResolutionStep(FunctionDecl *Function, DeclAccessPair Found, bool HadMultipleCandidates)
Add a new step in the initialization that resolves the address of an overloaded function to a specifi...
void AddArrayInitStep(QualType T, bool IsGNUExtension)
Add an array initialization step.
bool isConstructorInitialization() const
Determine whether this initialization is direct call to a constructor.
SmallVectorImpl< Step >::const_iterator step_iterator
OverloadCandidateSet & getFailedCandidateSet()
Retrieve a reference to the candidate set when overload resolution fails.
Describes an entity that is being initialized.
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a base class subobject.
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
VD Variable
When Kind == EK_Variable, EK_Member, EK_Binding, or EK_TemplateParameter, the variable,...
EntityKind getKind() const
Determine the kind of initialization.
DeclarationName getName() const
Retrieve the name of the entity being initialized.
QualType getType() const
Retrieve type being initialized.
ValueDecl * getDecl() const
Retrieve the variable, parameter, or field being initialized.
bool isImplicitMemberInitializer() const
Is this the implicit initialization of a member of a class from a defaulted constructor?
const InitializedEntity * getParent() const
Retrieve the parent of the entity being initialized, when the initialization itself is occurring with...
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
bool isParameterConsumed() const
Determine whether this initialization consumes the parameter.
static InitializedEntity InitializeElement(ASTContext &Context, unsigned Index, const InitializedEntity &Parent)
Create the initialization entity for an array element.
unsigned getElementIndex() const
If this is an array, vector, or complex number element, get the element's index.
void setElementIndex(unsigned Index)
If this is already the initializer for an array or vector element, sets the element index.
SourceLocation getCaptureLoc() const
Determine the location of the capture when initializing field from a captured variable in a lambda.
bool isParamOrTemplateParamKind() const
llvm::PointerIntPair< const CXXBaseSpecifier *, 1 > Base
When Kind == EK_Base, the base specifier that provides the base class.
bool allowsNRVO() const
Determine whether this initialization allows the named return value optimization, which also applies ...
bool isParameterKind() const
void dump() const
Dump a representation of the initialized entity to standard error, for debugging purposes.
EntityKind
Specifies the kind of entity being initialized.
@ EK_Variable
The entity being initialized is a variable.
@ EK_Temporary
The entity being initialized is a temporary object.
@ EK_Binding
The entity being initialized is a structured binding of a decomposition declaration.
@ EK_BlockElement
The entity being initialized is a field of block descriptor for the copied-in c++ object.
@ EK_MatrixElement
The entity being initialized is an element of a matrix.
@ 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, EK_MatrixElement, or EK_ComplexElement,...
bool isVariableLengthArrayNew() const
Determine whether this is an array new with an unknown bound.
llvm::PointerIntPair< ParmVarDecl *, 1 > Parameter
When Kind == EK_Parameter, the ParmVarDecl, with the integer indicating whether the parameter is "con...
const CXXBaseSpecifier * getBaseSpecifier() const
Retrieve the base specifier.
SourceLocation getReturnLoc() const
Determine the location of the 'return' keyword when initializing the result of a function call.
TypeSourceInfo * getTypeSourceInfo() const
Retrieve complete type-source information for the object being constructed, if known.
ObjCMethodDecl * getMethodDecl() const
Retrieve the ObjectiveC method being initialized.
An lvalue reference type, per C++11 [dcl.ref].
Represents the results of name lookup.
bool empty() const
Return true if no decls were found.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Represents a matrix type, as defined in the Matrix Types clang extensions.
QualType getElementType() const
Returns type of the elements being stored in the matrix.
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
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.
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)
llvm::MutableArrayRef< Expr * > getPersistentArgsArray(unsigned N)
Provide storage for any Expr* arg that must be preserved until deferred template candidates are deduc...
@ 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.
CandidateSetKind getKind() const
Represents a parameter to a function.
PointerType - C99 6.7.5.1 - Pointer Declarators.
bool NeedsStdLibCxxWorkaroundBefore(std::uint64_t FixedVersion)
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 compatiblyIncludes(Qualifiers other, const ASTContext &Ctx) const
Determines if these qualifiers compatibly include another set.
bool hasAddressSpace() const
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
Returns true if address space A is equal to or a superset of B.
Qualifiers withoutAddressSpace() const
static Qualifiers fromCVRMask(unsigned CVR)
bool hasObjCLifetime() const
LangAS getAddressSpace() const
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
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.
bool hasUninitializedExplicitInitFields() const
specific_decl_iterator< FieldDecl > field_iterator
field_iterator field_begin() const
Base for LValueReferenceType and RValueReferenceType.
bool isSpelledAsLValue() const
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
SemaDiagnosticBuilder DiagCompat(SourceLocation Loc, unsigned CompatDiagId)
Emit a compatibility diagnostic.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
bool transformInitList(const InitializedEntity &Entity, InitListExpr *Init)
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.
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 ...
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...
Preprocessor & getPreprocessor() const
const ExpressionEvaluationContextRecord & currentEvaluationContext() const
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 ActOnDesignatedInitializer(Designation &Desig, SourceLocation EqualOrColonLoc, bool GNUSyntax, ExprResult Init)
FPOptionsOverride CurFPFeatureOverrides()
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.
ExpressionEvaluationContextRecord & parentEvaluationContext()
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we're implicitly casting from a _Nullable pointer type to a _Nonnull one.
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over....
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
ASTContext & getASTContext() const
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
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 AddConversionCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, bool AllowExplicit, bool AllowResultConversion=true, bool StrictPackMatch=false)
AddConversionCandidate - Add a C++ conversion function as a candidate in the candidate set (C++ [over...
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
CXXConstructorDecl * LookupDefaultConstructor(CXXRecordDecl *Class)
Look up the default constructor for the given class.
const LangOptions & getLangOpts() const
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void 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={}, OverloadCandidateParamOrder PO={}, bool AggregateCandidateDeduction=false, bool StrictPackMatch=false)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
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.
ReferenceConversionsScope::ReferenceConversions ReferenceConversions
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
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
bool IsAssignConvertCompatible(AssignConvertType ConvTy)
bool DiagnoseUseOfOverloadedDecl(NamedDecl *D, SourceLocation Loc)
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.
bool IsDerivedFrom(SourceLocation Loc, CXXRecordDecl *Derived, CXXRecordDecl *Base, CXXBasePaths &Paths)
Determine whether the type Derived is a C++ class that is derived from the type Base.
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair FoundDecl)
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 BoundsSafetyCheckInitialization(const InitializedEntity &Entity, const InitializationKind &Kind, AssignmentAction Action, QualType LHSType, Expr *RHSExpr)
Perform Bounds Safety Semantic checks for initializing a Bounds Safety pointer.
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.
TypeSourceInfo * SubstAutoTypeSourceInfoDependent(TypeSourceInfo *TypeWithAuto)
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,...
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=AllowFoldKind::No)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, ReferenceConversions *Conv=nullptr)
CompareReferenceRelationship - Compare the two types T1 and T2 to determine whether they are referenc...
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the initializer (and its subobjects) is sufficient for initializing the en...
QualType getCompletedType(Expr *E)
Get the type of expression E, triggering instantiation to complete the type if necessary – that is,...
SourceManager & SourceMgr
TypeSourceInfo * SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
NamespaceDecl * getStdNamespace() const
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
friend class InitializationSequence
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 CanPerformCopyInitialization(const InitializedEntity &Entity, ExprResult Init)
bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types.
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
CXXConstructorDecl * findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor, ConstructorUsingShadowDecl *DerivedShadow)
Given a derived-class using shadow declaration for a constructor and the correspnding base class cons...
ValueDecl * tryLookupUnambiguousFieldDecl(RecordDecl *ClassDecl, const IdentifierInfo *MemberOrBase)
Encodes a location in the source.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
bool isAtStartOfImmediateMacroExpansion(SourceLocation Loc, SourceLocation *MacroBegin=nullptr) const
Returns true if the given MacroID location points at the beginning of the immediate macro expansion.
A trivial tuple used to represent a source range.
void setBegin(SourceLocation b)
SourceLocation getEnd() const
SourceLocation getBegin() const
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3....
void setFromType(QualType T)
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion,...
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion,...
void setAsIdentityConversion()
StandardConversionSequence - Set the standard conversion sequence to the identity conversion.
void setToType(unsigned Idx, QualType T)
NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted, APValue &ConstantValue, QualType &ConstantType, bool IgnoreFloatToIntegralConversion=false) const
Check if this standard conversion sequence represents a narrowing conversion, according to C++11 [dcl...
void setAllToTypes(QualType T)
QualType getToType(unsigned Idx) const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
unsigned getLength() const
StringLiteralKind getKind() const
int64_t getCodeUnitS(size_t I, uint64_t BitWidth) const
StringRef getString() const
The base class of all kinds of template declarations (e.g., class, function, etc.).
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) 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.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceLocation getEndLoc() const
Get the end source location.
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
bool isBooleanType() const
bool isMFloat8Type() 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
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
CXXRecordDecl * castAsCXXRecordDecl() const
bool isConstantMatrixType() 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 isEnumeralType() 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.
RecordDecl * castAsRecordDecl() const
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 isMatrixType() const
EnumDecl * castAsEnumDecl() 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
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
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
DeclClass * getCorrectionDeclAs() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
const Expr * getInit() const
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
StorageDuration getStorageDuration() const
Get the storage duration of this variable, per C++ [basic.stc].
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
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
@ OS
Indicates that the tracking object is a descendant of a referenced-counted OSObject,...
void checkInitLifetime(Sema &SemaRef, const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the given expr (and its subobjects) is sufficient for initializing the ent...
The JSON file list parser is used to communicate input to InstallAPI.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
bool isa(CodeGen::Address addr)
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
OverloadingResult
OverloadingResult - Capture the result of performing overload resolution.
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
@ OR_Ambiguous
Ambiguous candidates found.
@ OR_No_Viable_Function
No viable function found.
@ ovl_fail_bad_conversion
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
MutableArrayRef< Expr * > MultiExprArg
@ SD_Thread
Thread storage duration.
@ SD_Static
Static storage duration.
@ SD_Automatic
Automatic storage duration (most local variables).
@ Result
The result type of a method or function.
const FunctionProtoType * T
@ 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.
@ Template
We are parsing a template declaration.
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.
CastKind
CastKind - The kind of operation required for a conversion.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
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)
SmallVector< CXXBaseSpecifier *, 4 > CXXCastPath
A simple array of base specifiers.
@ 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.
U cast(CodeGen::Address addr)
ConstructorInfo getConstructorInfo(NamedDecl *ND)
ActionResult< Expr * > ExprResult
@ 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.
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).
unsigned 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.
unsigned Viable
Viable - True to indicate that this overload candidate is viable.
bool InLifetimeExtendingContext
Whether we are currently in a context in which all temporaries must be lifetime-extended,...
SmallVector< MaterializeTemporaryExpr *, 8 > ForRangeLifetimeExtendTemps
P2718R0 - Lifetime extension in range-based for loops.
bool RebuildDefaultArgOrDefaultInit
Whether we should rebuild CXXDefaultArgExpr and CXXDefaultInitExpr.
std::optional< InitializationContext > DelayedDefaultInitializationContext
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion.