//===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file implements semantic analysis for initializers.

//

//===----------------------------------------------------------------------===//

#include "clang/AST/ASTContext.h"

#include "clang/AST/DeclObjC.h"

#include "clang/AST/ExprCXX.h"

#include "clang/AST/ExprObjC.h"

#include "clang/AST/ExprOpenMP.h"

#include "clang/AST/IgnoreExpr.h"

#include "clang/AST/TypeLoc.h"

#include "clang/Basic/CharInfo.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Basic/Specifiers.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Sema/Designator.h"

#include "clang/Sema/EnterExpressionEvaluationContext.h"

#include "clang/Sema/Initialization.h"

#include "clang/Sema/Lookup.h"

#include "clang/Sema/Ownership.h"

#include "clang/Sema/SemaInternal.h"

#include "llvm/ADT/APInt.h"

#include "llvm/ADT/FoldingSet.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/ADT/SmallString.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/raw_ostream.h"

using namespace clang;

//===----------------------------------------------------------------------===//

// Sema Initialization Checking

//===----------------------------------------------------------------------===//

/// Check whether T is compatible with a wide character type (wchar_t,

/// char16_t or char32_t).

static bool IsWideCharCompatible(QualType T, ASTContext &Context) {

  if (Context.typesAreCompatible(Context.getWideCharType(), T))

    return true;

  if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) {

    return Context.typesAreCompatible(Context.Char16Ty, T) ||

           Context.typesAreCompatible(Context.Char32Ty, T);

  }

  return false;

}

enum StringInitFailureKind {

  SIF_None,

  SIF_NarrowStringIntoWideChar,

  SIF_WideStringIntoChar,

  SIF_IncompatWideStringIntoWideChar,

  SIF_UTF8StringIntoPlainChar,

  SIF_PlainStringIntoUTF8Char,

  SIF_Other

};

/// Check whether the array of type AT can be initialized by the Init

/// expression by means of string initialization. Returns SIF_None if so,

/// otherwise returns a StringInitFailureKind that describes why the

/// initialization would not work.

static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT,

                                          ASTContext &Context) {

  if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))

    return SIF_Other;

  // See if this is a string literal or @encode.

  Init = Init->IgnoreParens();

  // Handle @encode, which is a narrow string.

  if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())

    return SIF_None;

  // Otherwise we can only handle string literals.

  StringLiteral *SL = dyn_cast<StringLiteral>(Init);

  if (!SL)

    return SIF_Other;

  const QualType ElemTy =

      Context.getCanonicalType(AT->getElementType()).getUnqualifiedType();

  auto IsCharOrUnsignedChar = [](const QualType &T) {

    const BuiltinType *BT = dyn_cast<BuiltinType>(T.getTypePtr());

    return BT && BT->isCharType() && BT->getKind() != BuiltinType::SChar;

  };

  switch (SL->getKind()) {

  case StringLiteralKind::UTF8:

    // char8_t array can be initialized with a UTF-8 string.

    // - C++20 [dcl.init.string] (DR)

    //   Additionally, an array of char or unsigned char may be initialized

    //   by a UTF-8 string literal.

    if (ElemTy->isChar8Type() ||

        (Context.getLangOpts().Char8 &&

         IsCharOrUnsignedChar(ElemTy.getCanonicalType())))

      return SIF_None;

    [[fallthrough]];

  case StringLiteralKind::Ordinary:

    // char array can be initialized with a narrow string.

    // Only allow char x[] = "foo";  not char x[] = L"foo";

    if (ElemTy->isCharType())

      return (SL->getKind() == StringLiteralKind::UTF8 &&

              Context.getLangOpts().Char8)

                 ? SIF_UTF8StringIntoPlainChar

                 : SIF_None;

    if (ElemTy->isChar8Type())

      return SIF_PlainStringIntoUTF8Char;

    if (IsWideCharCompatible(ElemTy, Context))

      return SIF_NarrowStringIntoWideChar;

    return SIF_Other;

  // C99 6.7.8p15 (with correction from DR343), or C11 6.7.9p15:

  // "An array with element type compatible with a qualified or unqualified

  // version of wchar_t, char16_t, or char32_t may be initialized by a wide

  // string literal with the corresponding encoding prefix (L, u, or U,

  // respectively), optionally enclosed in braces.

  case StringLiteralKind::UTF16:

    if (Context.typesAreCompatible(Context.Char16Ty, ElemTy))

      return SIF_None;

    if (ElemTy->isCharType() || ElemTy->isChar8Type())

      return SIF_WideStringIntoChar;

    if (IsWideCharCompatible(ElemTy, Context))

      return SIF_IncompatWideStringIntoWideChar;

    return SIF_Other;

  case StringLiteralKind::UTF32:

    if (Context.typesAreCompatible(Context.Char32Ty, ElemTy))

      return SIF_None;

    if (ElemTy->isCharType() || ElemTy->isChar8Type())

      return SIF_WideStringIntoChar;

    if (IsWideCharCompatible(ElemTy, Context))

      return SIF_IncompatWideStringIntoWideChar;

    return SIF_Other;

  case StringLiteralKind::Wide:

    if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy))

      return SIF_None;

    if (ElemTy->isCharType() || ElemTy->isChar8Type())

      return SIF_WideStringIntoChar;

    if (IsWideCharCompatible(ElemTy, Context))

      return SIF_IncompatWideStringIntoWideChar;

    return SIF_Other;

  case StringLiteralKind::Unevaluated:

    assert(false && "Unevaluated string literal in initialization");

    break;

  }

  llvm_unreachable("missed a StringLiteral kind?");

}

static StringInitFailureKind IsStringInit(Expr *init, QualType declType,

                                          ASTContext &Context) {

  const ArrayType *arrayType = Context.getAsArrayType(declType);

  if (!arrayType)

    return SIF_Other;

  return IsStringInit(init, arrayType, Context);

}

bool Sema::IsStringInit(Expr *Init, const ArrayType *AT) {

  return ::IsStringInit(Init, AT, Context) == SIF_None;

}

/// Update the type of a string literal, including any surrounding parentheses,

/// to match the type of the object which it is initializing.

static void updateStringLiteralType(Expr *E, QualType Ty) {

  while (true) {

    E->setType(Ty);

    E->setValueKind(VK_PRValue);

    if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))

      break;

    E = IgnoreParensSingleStep(E);

  }

}

/// Fix a compound literal initializing an array so it's correctly marked

/// as an rvalue.

static void updateGNUCompoundLiteralRValue(Expr *E) {

  while (true) {

    E->setValueKind(VK_PRValue);

    if (isa<CompoundLiteralExpr>(E))

      break;

    E = IgnoreParensSingleStep(E);

  }

}

static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,

                            Sema &S) {

  // Get the length of the string as parsed.

  auto *ConstantArrayTy =

      cast<ConstantArrayType>(Str->getType()->getAsArrayTypeUnsafe());

  uint64_t StrLength = ConstantArrayTy->getSize().getZExtValue();

  if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {

    // C99 6.7.8p14. We have an array of character type with unknown size

    // being initialized to a string literal.

    llvm::APInt ConstVal(32, StrLength);

    // Return a new array type (C99 6.7.8p22).

    DeclT = S.Context.getConstantArrayType(

        IAT->getElementType(), ConstVal, nullptr, ArraySizeModifier::Normal, 0);

    updateStringLiteralType(Str, DeclT);

    return;

  }

  const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);

  // We have an array of character type with known size.  However,

  // the size may be smaller or larger than the string we are initializing.

  // FIXME: Avoid truncation for 64-bit length strings.

  if (S.getLangOpts().CPlusPlus) {

    if (StringLiteral *SL = dyn_cast<StringLiteral>(Str->IgnoreParens())) {

      // For Pascal strings it's OK to strip off the terminating null character,

      // so the example below is valid:

      //

      // unsigned char a[2] = "\pa";

      if (SL->isPascal())

        StrLength--;

    }

    // [dcl.init.string]p2

    if (StrLength > CAT->getSize().getZExtValue())

      S.Diag(Str->getBeginLoc(),

             diag::err_initializer_string_for_char_array_too_long)

          << CAT->getSize().getZExtValue() << StrLength

          << Str->getSourceRange();

  } else {

    // C99 6.7.8p14.

    if (StrLength-1 > CAT->getSize().getZExtValue())

      S.Diag(Str->getBeginLoc(),

             diag::ext_initializer_string_for_char_array_too_long)

          << Str->getSourceRange();

  }

  // Set the type to the actual size that we are initializing.  If we have

  // something like:

  //   char x[1] = "foo";

  // then this will set the string literal's type to char[1].

  updateStringLiteralType(Str, DeclT);

}

//===----------------------------------------------------------------------===//

// Semantic checking for initializer lists.

//===----------------------------------------------------------------------===//

namespace {

/// Semantic checking for initializer lists.

///

/// The InitListChecker class contains a set of routines that each

/// handle the initialization of a certain kind of entity, e.g.,

/// arrays, vectors, struct/union types, scalars, etc. The

/// InitListChecker itself performs a recursive walk of the subobject

/// structure of the type to be initialized, while stepping through

/// the initializer list one element at a time. The IList and Index

/// parameters to each of the Check* routines contain the active

/// (syntactic) initializer list and the index into that initializer

/// list that represents the current initializer. Each routine is

/// responsible for moving that Index forward as it consumes elements.

///

/// Each Check* routine also has a StructuredList/StructuredIndex

/// arguments, which contains the current "structured" (semantic)

/// initializer list and the index into that initializer list where we

/// are copying initializers as we map them over to the semantic

/// list. Once we have completed our recursive walk of the subobject

/// structure, we will have constructed a full semantic initializer

/// list.

///

/// C99 designators cause changes in the initializer list traversal,

/// because they make the initialization "jump" into a specific

/// subobject and then continue the initialization from that

/// point. CheckDesignatedInitializer() recursively steps into the

/// designated subobject and manages backing out the recursion to

/// initialize the subobjects after the one designated.

///

/// If an initializer list contains any designators, we build a placeholder

/// structured list even in 'verify only' mode, so that we can track which

/// elements need 'empty' initializtion.

class InitListChecker {

  Sema &SemaRef;

  bool hadError = false;

  bool VerifyOnly; // No diagnostics.

  bool TreatUnavailableAsInvalid; // Used only in VerifyOnly mode.

  bool InOverloadResolution;

  InitListExpr *FullyStructuredList = nullptr;

  NoInitExpr *DummyExpr = nullptr;

  SmallVectorImpl<QualType> *AggrDeductionCandidateParamTypes = nullptr;

  NoInitExpr *getDummyInit() {

    if (!DummyExpr)

      DummyExpr = new (SemaRef.Context) NoInitExpr(SemaRef.Context.VoidTy);

    return DummyExpr;

  }

  void CheckImplicitInitList(const InitializedEntity &Entity,

                             InitListExpr *ParentIList, QualType T,

                             unsigned &Index, InitListExpr *StructuredList,

                             unsigned &StructuredIndex);

  void CheckExplicitInitList(const InitializedEntity &Entity,

                             InitListExpr *IList, QualType &T,

                             InitListExpr *StructuredList,

                             bool TopLevelObject = false);

  void CheckListElementTypes(const InitializedEntity &Entity,

                             InitListExpr *IList, QualType &DeclType,

                             bool SubobjectIsDesignatorContext,

                             unsigned &Index,

                             InitListExpr *StructuredList,

                             unsigned &StructuredIndex,

                             bool TopLevelObject = false);

  void CheckSubElementType(const InitializedEntity &Entity,

                           InitListExpr *IList, QualType ElemType,

                           unsigned &Index,

                           InitListExpr *StructuredList,

                           unsigned &StructuredIndex,

                           bool DirectlyDesignated = false);

  void CheckComplexType(const InitializedEntity &Entity,

                        InitListExpr *IList, QualType DeclType,

                        unsigned &Index,

                        InitListExpr *StructuredList,

                        unsigned &StructuredIndex);

  void CheckScalarType(const InitializedEntity &Entity,

                       InitListExpr *IList, QualType DeclType,

                       unsigned &Index,

                       InitListExpr *StructuredList,

                       unsigned &StructuredIndex);

  void CheckReferenceType(const InitializedEntity &Entity,

                          InitListExpr *IList, QualType DeclType,

                          unsigned &Index,

                          InitListExpr *StructuredList,

                          unsigned &StructuredIndex);

  void CheckVectorType(const InitializedEntity &Entity,

                       InitListExpr *IList, QualType DeclType, unsigned &Index,

                       InitListExpr *StructuredList,

                       unsigned &StructuredIndex);

  void CheckStructUnionTypes(const InitializedEntity &Entity,

                             InitListExpr *IList, QualType DeclType,

                             CXXRecordDecl::base_class_const_range Bases,

                             RecordDecl::field_iterator Field,

                             bool SubobjectIsDesignatorContext, unsigned &Index,

                             InitListExpr *StructuredList,

                             unsigned &StructuredIndex,

                             bool TopLevelObject = false);

  void CheckArrayType(const InitializedEntity &Entity,

                      InitListExpr *IList, QualType &DeclType,

                      llvm::APSInt elementIndex,

                      bool SubobjectIsDesignatorContext, unsigned &Index,

                      InitListExpr *StructuredList,

                      unsigned &StructuredIndex);

  bool CheckDesignatedInitializer(const InitializedEntity &Entity,

                                  InitListExpr *IList, DesignatedInitExpr *DIE,

                                  unsigned DesigIdx,

                                  QualType &CurrentObjectType,

                                  RecordDecl::field_iterator *NextField,

                                  llvm::APSInt *NextElementIndex,

                                  unsigned &Index,

                                  InitListExpr *StructuredList,

                                  unsigned &StructuredIndex,

                                  bool FinishSubobjectInit,

                                  bool TopLevelObject);

  InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,

                                           QualType CurrentObjectType,

                                           InitListExpr *StructuredList,

                                           unsigned StructuredIndex,

                                           SourceRange InitRange,

                                           bool IsFullyOverwritten = false);

  void UpdateStructuredListElement(InitListExpr *StructuredList,

                                   unsigned &StructuredIndex,

                                   Expr *expr);

  InitListExpr *createInitListExpr(QualType CurrentObjectType,

                                   SourceRange InitRange,

                                   unsigned ExpectedNumInits);

  int numArrayElements(QualType DeclType);

  int numStructUnionElements(QualType DeclType);

  static RecordDecl *getRecordDecl(QualType DeclType);

  ExprResult PerformEmptyInit(SourceLocation Loc,

                              const InitializedEntity &Entity);

  /// Diagnose that OldInit (or part thereof) has been overridden by NewInit.

  void diagnoseInitOverride(Expr *OldInit, SourceRange NewInitRange,

                            bool UnionOverride = false,

                            bool FullyOverwritten = true) {

    // Overriding an initializer via a designator is valid with C99 designated

    // initializers, but ill-formed with C++20 designated initializers.

    unsigned DiagID =

        SemaRef.getLangOpts().CPlusPlus

            ? (UnionOverride ? diag::ext_initializer_union_overrides

                             : diag::ext_initializer_overrides)

            : diag::warn_initializer_overrides;

    if (InOverloadResolution && SemaRef.getLangOpts().CPlusPlus) {

      // In overload resolution, we have to strictly enforce the rules, and so

      // don't allow any overriding of prior initializers. This matters for a

      // case such as:

      //

      //   union U { int a, b; };

      //   struct S { int a, b; };

      //   void f(U), f(S);

      //

      // Here, f({.a = 1, .b = 2}) is required to call the struct overload. For

      // consistency, we disallow all overriding of prior initializers in

      // overload resolution, not only overriding of union members.

      hadError = true;

    } else if (OldInit->getType().isDestructedType() && !FullyOverwritten) {

      // If we'll be keeping around the old initializer but overwriting part of

      // the object it initialized, and that object is not trivially

      // destructible, this can leak. Don't allow that, not even as an

      // extension.

      //

      // FIXME: It might be reasonable to allow this in cases where the part of

      // the initializer that we're overriding has trivial destruction.

      DiagID = diag::err_initializer_overrides_destructed;

    } else if (!OldInit->getSourceRange().isValid()) {

      // We need to check on source range validity because the previous

      // initializer does not have to be an explicit initializer. e.g.,

      //

      // struct P { int a, b; };

      // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };

      //

      // There is an overwrite taking place because the first braced initializer

      // list "{ .a = 2 }" already provides value for .p.b (which is zero).

      //

      // Such overwrites are harmless, so we don't diagnose them. (Note that in

      // C++, this cannot be reached unless we've already seen and diagnosed a

      // different conformance issue, such as a mixture of designated and

      // non-designated initializers or a multi-level designator.)

      return;

    }

    if (!VerifyOnly) {

      SemaRef.Diag(NewInitRange.getBegin(), DiagID)

          << NewInitRange << FullyOverwritten << OldInit->getType();

      SemaRef.Diag(OldInit->getBeginLoc(), diag::note_previous_initializer)

          << (OldInit->HasSideEffects(SemaRef.Context) && FullyOverwritten)

          << OldInit->getSourceRange();

    }

  }

  // Explanation on the "FillWithNoInit" mode:

  //

  // Assume we have the following definitions (Case#1):

  // struct P { char x[6][6]; } xp = { .x[1] = "bar" };

  // struct PP { struct P lp; } l = { .lp = xp, .lp.x[1][2] = 'f' };

  //

  // l.lp.x[1][0..1] should not be filled with implicit initializers because the

  // "base" initializer "xp" will provide values for them; l.lp.x[1] will be "baf".

  //

  // But if we have (Case#2):

  // struct PP l = { .lp = xp, .lp.x[1] = { [2] = 'f' } };

  //

  // l.lp.x[1][0..1] are implicitly initialized and do not use values from the

  // "base" initializer; l.lp.x[1] will be "\0\0f\0\0\0".

  //

  // To distinguish Case#1 from Case#2, and also to avoid leaving many "holes"

  // in the InitListExpr, the "holes" in Case#1 are filled not with empty

  // initializers but with special "NoInitExpr" place holders, which tells the

  // CodeGen not to generate any initializers for these parts.

  void FillInEmptyInitForBase(unsigned Init, const CXXBaseSpecifier &Base,

                              const InitializedEntity &ParentEntity,

                              InitListExpr *ILE, bool &RequiresSecondPass,

                              bool FillWithNoInit);

  void FillInEmptyInitForField(unsigned Init, FieldDecl *Field,

                               const InitializedEntity &ParentEntity,

                               InitListExpr *ILE, bool &RequiresSecondPass,

                               bool FillWithNoInit = false);

  void FillInEmptyInitializations(const InitializedEntity &Entity,

                                  InitListExpr *ILE, bool &RequiresSecondPass,

                                  InitListExpr *OuterILE, unsigned OuterIndex,

                                  bool FillWithNoInit = false);

  bool CheckFlexibleArrayInit(const InitializedEntity &Entity,

                              Expr *InitExpr, FieldDecl *Field,

                              bool TopLevelObject);

  void CheckEmptyInitializable(const InitializedEntity &Entity,

                               SourceLocation Loc);

public:

  InitListChecker(

      Sema &S, const InitializedEntity &Entity, InitListExpr *IL, QualType &T,

      bool VerifyOnly, bool TreatUnavailableAsInvalid,

      bool InOverloadResolution = false,

      SmallVectorImpl<QualType> *AggrDeductionCandidateParamTypes = nullptr);

  InitListChecker(Sema &S, const InitializedEntity &Entity, InitListExpr *IL,

                  QualType &T,

                  SmallVectorImpl<QualType> &AggrDeductionCandidateParamTypes)

      : InitListChecker(S, Entity, IL, T, /*VerifyOnly=*/true,

                        /*TreatUnavailableAsInvalid=*/false,

                        /*InOverloadResolution=*/false,

                        &AggrDeductionCandidateParamTypes){};

  bool HadError() { return hadError; }

  // Retrieves the fully-structured initializer list used for

  // semantic analysis and code generation.

  InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }

};

} // end anonymous namespace

ExprResult InitListChecker::PerformEmptyInit(SourceLocation Loc,

                                             const InitializedEntity &Entity) {

  InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,

                                                            true);

  MultiExprArg SubInit;

  Expr *InitExpr;

  InitListExpr DummyInitList(SemaRef.Context, Loc, std::nullopt, Loc);

  // C++ [dcl.init.aggr]p7:

  //   If there are fewer initializer-clauses in the list than there are

  //   members in the aggregate, then each member not explicitly initialized

  //   ...

  bool EmptyInitList = SemaRef.getLangOpts().CPlusPlus11 &&

      Entity.getType()->getBaseElementTypeUnsafe()->isRecordType();

  if (EmptyInitList) {

    // C++1y / DR1070:

    //   shall be initialized [...] from an empty initializer list.

    //

    // We apply the resolution of this DR to C++11 but not C++98, since C++98

    // does not have useful semantics for initialization from an init list.

    // We treat this as copy-initialization, because aggregate initialization

    // always performs copy-initialization on its elements.

    //

    // Only do this if we're initializing a class type, to avoid filling in

    // the initializer list where possible.

    InitExpr = VerifyOnly

                   ? &DummyInitList

                   : new (SemaRef.Context)

                         InitListExpr(SemaRef.Context, Loc, std::nullopt, Loc);

    InitExpr->setType(SemaRef.Context.VoidTy);

    SubInit = InitExpr;

    Kind = InitializationKind::CreateCopy(Loc, Loc);

  } else {

    // C++03:

    //   shall be value-initialized.

  }

  InitializationSequence InitSeq(SemaRef, Entity, Kind, SubInit);

  // libstdc++4.6 marks the vector default constructor as explicit in

  // _GLIBCXX_DEBUG mode, so recover using the C++03 logic in that case.

  // stlport does so too. Look for std::__debug for libstdc++, and for

  // std:: for stlport.  This is effectively a compiler-side implementation of

  // LWG2193.

  if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==

          InitializationSequence::FK_ExplicitConstructor) {

    OverloadCandidateSet::iterator Best;

    OverloadingResult O =

        InitSeq.getFailedCandidateSet()

            .BestViableFunction(SemaRef, Kind.getLocation(), Best);

    (void)O;

    assert(O == OR_Success && "Inconsistent overload resolution");

    CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);

    CXXRecordDecl *R = CtorDecl->getParent();

    if (CtorDecl->getMinRequiredArguments() == 0 &&

        CtorDecl->isExplicit() && R->getDeclName() &&

        SemaRef.SourceMgr.isInSystemHeader(CtorDecl->getLocation())) {

      bool IsInStd = false;

      for (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(R->getDeclContext());

           ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {

        if (SemaRef.getStdNamespace()->InEnclosingNamespaceSetOf(ND))

          IsInStd = true;

      }

      if (IsInStd && llvm::StringSwitch<bool>(R->getName())

              .Cases("basic_string", "deque", "forward_list", true)

              .Cases("list", "map", "multimap", "multiset", true)

              .Cases("priority_queue", "queue", "set", "stack", true)

              .Cases("unordered_map", "unordered_set", "vector", true)

              .Default(false)) {

        InitSeq.InitializeFrom(

            SemaRef, Entity,

            InitializationKind::CreateValue(Loc, Loc, Loc, true),

            MultiExprArg(), /*TopLevelOfInitList=*/false,

            TreatUnavailableAsInvalid);

        // Emit a warning for this.  System header warnings aren't shown

        // by default, but people working on system headers should see it.

        if (!VerifyOnly) {

          SemaRef.Diag(CtorDecl->getLocation(),

                       diag::warn_invalid_initializer_from_system_header);

          if (Entity.getKind() == InitializedEntity::EK_Member)

            SemaRef.Diag(Entity.getDecl()->getLocation(),

                         diag::note_used_in_initialization_here);

          else if (Entity.getKind() == InitializedEntity::EK_ArrayElement)

            SemaRef.Diag(Loc, diag::note_used_in_initialization_here);

        }

      }

    }

  }

  if (!InitSeq) {

    if (!VerifyOnly) {

      InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);

      if (Entity.getKind() == InitializedEntity::EK_Member)

        SemaRef.Diag(Entity.getDecl()->getLocation(),

                     diag::note_in_omitted_aggregate_initializer)

          << /*field*/1 << Entity.getDecl();

      else if (Entity.getKind() == InitializedEntity::EK_ArrayElement) {

        bool IsTrailingArrayNewMember =

            Entity.getParent() &&

            Entity.getParent()->isVariableLengthArrayNew();

        SemaRef.Diag(Loc, diag::note_in_omitted_aggregate_initializer)

          << (IsTrailingArrayNewMember ? 2 : /*array element*/0)

          << Entity.getElementIndex();

      }

    }

    hadError = true;

    return ExprError();

  }

  return VerifyOnly ? ExprResult()

                    : InitSeq.Perform(SemaRef, Entity, Kind, SubInit);

}

void InitListChecker::CheckEmptyInitializable(const InitializedEntity &Entity,

                                              SourceLocation Loc) {

  // If we're building a fully-structured list, we'll check this at the end

  // once we know which elements are actually initialized. Otherwise, we know

  // that there are no designators so we can just check now.

  if (FullyStructuredList)

    return;

  PerformEmptyInit(Loc, Entity);

}

void InitListChecker::FillInEmptyInitForBase(

    unsigned Init, const CXXBaseSpecifier &Base,

    const InitializedEntity &ParentEntity, InitListExpr *ILE,

    bool &RequiresSecondPass, bool FillWithNoInit) {

  InitializedEntity BaseEntity = InitializedEntity::InitializeBase(

      SemaRef.Context, &Base, false, &ParentEntity);

  if (Init >= ILE->getNumInits() || !ILE->getInit(Init)) {

    ExprResult BaseInit = FillWithNoInit

                              ? new (SemaRef.Context) NoInitExpr(Base.getType())

                              : PerformEmptyInit(ILE->getEndLoc(), BaseEntity);

    if (BaseInit.isInvalid()) {

      hadError = true;

      return;

    }

    if (!VerifyOnly) {

      assert(Init < ILE->getNumInits() && "should have been expanded");

      ILE->setInit(Init, BaseInit.getAs<Expr>());

    }

  } else if (InitListExpr *InnerILE =

                 dyn_cast<InitListExpr>(ILE->getInit(Init))) {

    FillInEmptyInitializations(BaseEntity, InnerILE, RequiresSecondPass,

                               ILE, Init, FillWithNoInit);

  } else if (DesignatedInitUpdateExpr *InnerDIUE =

               dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init))) {

    FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),

                               RequiresSecondPass, ILE, Init,

                               /*FillWithNoInit =*/true);

  }

}

void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field,

                                        const InitializedEntity &ParentEntity,

                                              InitListExpr *ILE,

                                              bool &RequiresSecondPass,

                                              bool FillWithNoInit) {

  SourceLocation Loc = ILE->getEndLoc();

  unsigned NumInits = ILE->getNumInits();

  InitializedEntity MemberEntity

    = InitializedEntity::InitializeMember(Field, &ParentEntity);

  if (Init >= NumInits || !ILE->getInit(Init)) {

    if (const RecordType *RType = ILE->getType()->getAs<RecordType>())

      if (!RType->getDecl()->isUnion())

        assert((Init < NumInits || VerifyOnly) &&

               "This ILE should have been expanded");

    if (FillWithNoInit) {

      assert(!VerifyOnly && "should not fill with no-init in verify-only mode");

      Expr *Filler = new (SemaRef.Context) NoInitExpr(Field->getType());

      if (Init < NumInits)

        ILE->setInit(Init, Filler);

      else

        ILE->updateInit(SemaRef.Context, Init, Filler);

      return;

    }

    // C++1y [dcl.init.aggr]p7:

    //   If there are fewer initializer-clauses in the list than there are

    //   members in the aggregate, then each member not explicitly initialized

    //   shall be initialized from its brace-or-equal-initializer [...]

    if (Field->hasInClassInitializer()) {

      if (VerifyOnly)

        return;

      ExprResult DIE = SemaRef.BuildCXXDefaultInitExpr(Loc, Field);

      if (DIE.isInvalid()) {

        hadError = true;

        return;

      }

      SemaRef.checkInitializerLifetime(MemberEntity, DIE.get());

      if (Init < NumInits)

        ILE->setInit(Init, DIE.get());

      else {

        ILE->updateInit(SemaRef.Context, Init, DIE.get());

        RequiresSecondPass = true;

      }

      return;

    }

    if (Field->getType()->isReferenceType()) {

      if (!VerifyOnly) {

        // C++ [dcl.init.aggr]p9:

        //   If an incomplete or empty initializer-list leaves a

        //   member of reference type uninitialized, the program is

        //   ill-formed.

        SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)

            << Field->getType()

            << (ILE->isSyntacticForm() ? ILE : ILE->getSyntacticForm())

                   ->getSourceRange();

        SemaRef.Diag(Field->getLocation(), diag::note_uninit_reference_member);

      }

      hadError = true;

      return;

    }

    ExprResult MemberInit = PerformEmptyInit(Loc, MemberEntity);

    if (MemberInit.isInvalid()) {

      hadError = true;

      return;

    }

    if (hadError || VerifyOnly) {

      // Do nothing

    } else if (Init < NumInits) {

      ILE->setInit(Init, MemberInit.getAs<Expr>());

    } else if (!isa<ImplicitValueInitExpr>(MemberInit.get())) {

      // Empty initialization requires a constructor call, so

      // extend the initializer list to include the constructor

      // call and make a note that we'll need to take another pass

      // through the initializer list.

      ILE->updateInit(SemaRef.Context, Init, MemberInit.getAs<Expr>());

      RequiresSecondPass = true;

    }

  } else if (InitListExpr *InnerILE

               = dyn_cast<InitListExpr>(ILE->getInit(Init))) {

    FillInEmptyInitializations(MemberEntity, InnerILE,

                               RequiresSecondPass, ILE, Init, FillWithNoInit);

  } else if (DesignatedInitUpdateExpr *InnerDIUE =

                 dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init))) {

    FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),

                               RequiresSecondPass, ILE, Init,

                               /*FillWithNoInit =*/true);

  }

}

/// Recursively replaces NULL values within the given initializer list

/// with expressions that perform value-initialization of the

/// appropriate type, and finish off the InitListExpr formation.

void

InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity,

                                            InitListExpr *ILE,

                                            bool &RequiresSecondPass,

                                            InitListExpr *OuterILE,

                                            unsigned OuterIndex,

                                            bool FillWithNoInit) {

  assert((ILE->getType() != SemaRef.Context.VoidTy) &&

         "Should not have void type");

  // We don't need to do any checks when just filling NoInitExprs; that can't

  // fail.

  if (FillWithNoInit && VerifyOnly)

    return;

  // If this is a nested initializer list, we might have changed its contents

  // (and therefore some of its properties, such as instantiation-dependence)

  // while filling it in. Inform the outer initializer list so that its state

  // can be updated to match.

  // FIXME: We should fully build the inner initializers before constructing

  // the outer InitListExpr instead of mutating AST nodes after they have

  // been used as subexpressions of other nodes.

  struct UpdateOuterILEWithUpdatedInit {

    InitListExpr *Outer;

    unsigned OuterIndex;

    ~UpdateOuterILEWithUpdatedInit() {

      if (Outer)

        Outer->setInit(OuterIndex, Outer->getInit(OuterIndex));

    }

  } UpdateOuterRAII = {OuterILE, OuterIndex};

  // A transparent ILE is not performing aggregate initialization and should

  // not be filled in.

  if (ILE->isTransparent())

    return;

  if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {

    const RecordDecl *RDecl = RType->getDecl();

    if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())

      FillInEmptyInitForField(0, ILE->getInitializedFieldInUnion(),

                              Entity, ILE, RequiresSecondPass, FillWithNoInit);

    else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&

             cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {

      for (auto *Field : RDecl->fields()) {

        if (Field->hasInClassInitializer()) {

          FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass,

                                  FillWithNoInit);

          break;

        }

      }

    } else {

      // The fields beyond ILE->getNumInits() are default initialized, so in

      // order to leave them uninitialized, the ILE is expanded and the extra

      // fields are then filled with NoInitExpr.

      unsigned NumElems = numStructUnionElements(ILE->getType());

      if (!RDecl->isUnion() && RDecl->hasFlexibleArrayMember())

        ++NumElems;

      if (!VerifyOnly && ILE->getNumInits() < NumElems)

        ILE->resizeInits(SemaRef.Context, NumElems);

      unsigned Init = 0;

      if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {

        for (auto &Base : CXXRD->bases()) {

          if (hadError)

            return;

          FillInEmptyInitForBase(Init, Base, Entity, ILE, RequiresSecondPass,

                                 FillWithNoInit);

          ++Init;

        }

      }

      for (auto *Field : RDecl->fields()) {

        if (Field->isUnnamedBitfield())

          continue;

        if (hadError)

          return;

        FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass,

                                FillWithNoInit);

        if (hadError)

          return;

        ++Init;

        // Only look at the first initialization of a union.

        if (RDecl->isUnion())

          break;

      }

    }

    return;

  }

  QualType ElementType;

  InitializedEntity ElementEntity = Entity;

  unsigned NumInits = ILE->getNumInits();

  unsigned NumElements = NumInits;

  if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {

    ElementType = AType->getElementType();

    if (const auto *CAType = dyn_cast<ConstantArrayType>(AType))

      NumElements = CAType->getSize().getZExtValue();

    // For an array new with an unknown bound, ask for one additional element

    // in order to populate the array filler.

    if (Entity.isVariableLengthArrayNew())

      ++NumElements;

    ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,

                                                         0, Entity);

  } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {

    ElementType = VType->getElementType();

    NumElements = VType->getNumElements();

    ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,

                                                         0, Entity);

  } else

    ElementType = ILE->getType();

  bool SkipEmptyInitChecks = false;

  for (unsigned Init = 0; Init != NumElements; ++Init) {

    if (hadError)

      return;

    if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||

        ElementEntity.getKind() == InitializedEntity::EK_VectorElement)

      ElementEntity.setElementIndex(Init);

    if (Init >= NumInits && (ILE->hasArrayFiller() || SkipEmptyInitChecks))

      return;

    Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr);

    if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())

      ILE->setInit(Init, ILE->getArrayFiller());

    else if (!InitExpr && !ILE->hasArrayFiller()) {

      // In VerifyOnly mode, there's no point performing empty initialization

      // more than once.

      if (SkipEmptyInitChecks)

        continue;

      Expr *Filler = nullptr;

      if (FillWithNoInit)

        Filler = new (SemaRef.Context) NoInitExpr(ElementType);

      else {

        ExprResult ElementInit =

            PerformEmptyInit(ILE->getEndLoc(), ElementEntity);

        if (ElementInit.isInvalid()) {

          hadError = true;

          return;

        }

        Filler = ElementInit.getAs<Expr>();

      }

      if (hadError) {

        // Do nothing

      } else if (VerifyOnly) {

        SkipEmptyInitChecks = true;

      } else if (Init < NumInits) {

        // For arrays, just set the expression used for value-initialization

        // of the "holes" in the array.

        if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)

          ILE->setArrayFiller(Filler);

        else

          ILE->setInit(Init, Filler);