contrib/llvm/tools/clang/lib/Sema/SemaInit.cpp

   1 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements semantic analysis for initializers.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/ASTContext.h"
  15 #include "clang/AST/DeclObjC.h"
  16 #include "clang/AST/ExprCXX.h"
  17 #include "clang/AST/ExprObjC.h"
  18 #include "clang/AST/TypeLoc.h"
  19 #include "clang/Basic/TargetInfo.h"
  20 #include "clang/Sema/Designator.h"
  21 #include "clang/Sema/Initialization.h"
  22 #include "clang/Sema/Lookup.h"
  23 #include "clang/Sema/SemaInternal.h"
  24 #include "llvm/ADT/APInt.h"
  25 #include "llvm/ADT/SmallString.h"
  26 #include "llvm/Support/ErrorHandling.h"
  27 #include "llvm/Support/raw_ostream.h"
  28
  29 using namespace clang;
  30
  31 //===----------------------------------------------------------------------===//
  32 // Sema Initialization Checking
  33 //===----------------------------------------------------------------------===//
  34
  35 /// \brief Check whether T is compatible with a wide character type (wchar_t,
  36 /// char16_t or char32_t).
  37 static bool IsWideCharCompatible(QualType T, ASTContext &Context) {
  38   if (Context.typesAreCompatible(Context.getWideCharType(), T))
  39     return true;
  40   if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) {
  41     return Context.typesAreCompatible(Context.Char16Ty, T) ||
  42            Context.typesAreCompatible(Context.Char32Ty, T);
  43   }
  44   return false;
  45 }
  46
  47 enum StringInitFailureKind {
  48   SIF_None,
  49   SIF_NarrowStringIntoWideChar,
  50   SIF_WideStringIntoChar,
  51   SIF_IncompatWideStringIntoWideChar,
  52   SIF_Other
  53 };
  54
  55 /// \brief Check whether the array of type AT can be initialized by the Init
  56 /// expression by means of string initialization. Returns SIF_None if so,
  57 /// otherwise returns a StringInitFailureKind that describes why the
  58 /// initialization would not work.
  59 static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT,
  60                                           ASTContext &Context) {
  61   if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
  62     return SIF_Other;
  63
  64   // See if this is a string literal or @encode.
  65   Init = Init->IgnoreParens();
  66
  67   // Handle @encode, which is a narrow string.
  68   if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
  69     return SIF_None;
  70
  71   // Otherwise we can only handle string literals.
  72   StringLiteral *SL = dyn_cast<StringLiteral>(Init);
  73   if (!SL)
  74     return SIF_Other;
  75
  76   const QualType ElemTy =
  77       Context.getCanonicalType(AT->getElementType()).getUnqualifiedType();
  78
  79   switch (SL->getKind()) {
  80   case StringLiteral::Ascii:
  81   case StringLiteral::UTF8:
  82     // char array can be initialized with a narrow string.
  83     // Only allow char x[] = "foo";  not char x[] = L"foo";
  84     if (ElemTy->isCharType())
  85       return SIF_None;
  86     if (IsWideCharCompatible(ElemTy, Context))
  87       return SIF_NarrowStringIntoWideChar;
  88     return SIF_Other;
  89   // C99 6.7.8p15 (with correction from DR343), or C11 6.7.9p15:
  90   // "An array with element type compatible with a qualified or unqualified
  91   // version of wchar_t, char16_t, or char32_t may be initialized by a wide
  92   // string literal with the corresponding encoding prefix (L, u, or U,
  93   // respectively), optionally enclosed in braces.
  94   case StringLiteral::UTF16:
  95     if (Context.typesAreCompatible(Context.Char16Ty, ElemTy))
  96       return SIF_None;
  97     if (ElemTy->isCharType())
  98       return SIF_WideStringIntoChar;
  99     if (IsWideCharCompatible(ElemTy, Context))
 100       return SIF_IncompatWideStringIntoWideChar;
 101     return SIF_Other;
 102   case StringLiteral::UTF32:
 103     if (Context.typesAreCompatible(Context.Char32Ty, ElemTy))
 104       return SIF_None;
 105     if (ElemTy->isCharType())
 106       return SIF_WideStringIntoChar;
 107     if (IsWideCharCompatible(ElemTy, Context))
 108       return SIF_IncompatWideStringIntoWideChar;
 109     return SIF_Other;
 110   case StringLiteral::Wide:
 111     if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy))
 112       return SIF_None;
 113     if (ElemTy->isCharType())
 114       return SIF_WideStringIntoChar;
 115     if (IsWideCharCompatible(ElemTy, Context))
 116       return SIF_IncompatWideStringIntoWideChar;
 117     return SIF_Other;
 118   }
 119
 120   llvm_unreachable("missed a StringLiteral kind?");
 121 }
 122
 123 static StringInitFailureKind IsStringInit(Expr *init, QualType declType,
 124                                           ASTContext &Context) {
 125   const ArrayType *arrayType = Context.getAsArrayType(declType);
 126   if (!arrayType)
 127     return SIF_Other;
 128   return IsStringInit(init, arrayType, Context);
 129 }
 130
 131 /// Update the type of a string literal, including any surrounding parentheses,
 132 /// to match the type of the object which it is initializing.
 133 static void updateStringLiteralType(Expr *E, QualType Ty) {
 134   while (true) {
 135     E->setType(Ty);
 136     if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
 137       break;
 138     else if (ParenExpr *PE = dyn_cast<ParenExpr>(E))
 139       E = PE->getSubExpr();
 140     else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
 141       E = UO->getSubExpr();
 142     else if (GenericSelectionExpr *GSE = dyn_cast<GenericSelectionExpr>(E))
 143       E = GSE->getResultExpr();
 144     else
 145       llvm_unreachable("unexpected expr in string literal init");
 146   }
 147 }
 148
 149 static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,
 150                             Sema &S) {
 151   // Get the length of the string as parsed.
 152   auto *ConstantArrayTy =
 153       cast<ConstantArrayType>(Str->getType()->getAsArrayTypeUnsafe());
 154   uint64_t StrLength = ConstantArrayTy->getSize().getZExtValue();
 155
 156   if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
 157     // C99 6.7.8p14. We have an array of character type with unknown size
 158     // being initialized to a string literal.
 159     llvm::APInt ConstVal(32, StrLength);
 160     // Return a new array type (C99 6.7.8p22).
 161     DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
 162                                            ConstVal,
 163                                            ArrayType::Normal, 0);
 164     updateStringLiteralType(Str, DeclT);
 165     return;
 166   }
 167
 168   const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
 169
 170   // We have an array of character type with known size.  However,
 171   // the size may be smaller or larger than the string we are initializing.
 172   // FIXME: Avoid truncation for 64-bit length strings.
 173   if (S.getLangOpts().CPlusPlus) {
 174     if (StringLiteral *SL = dyn_cast<StringLiteral>(Str->IgnoreParens())) {
 175       // For Pascal strings it's OK to strip off the terminating null character,
 176       // so the example below is valid:
 177       //
 178       // unsigned char a[2] = "\pa";
 179       if (SL->isPascal())
 180         StrLength--;
 181     }
 182
 183     // [dcl.init.string]p2
 184     if (StrLength > CAT->getSize().getZExtValue())
 185       S.Diag(Str->getLocStart(),
 186              diag::err_initializer_string_for_char_array_too_long)
 187         << Str->getSourceRange();
 188   } else {
 189     // C99 6.7.8p14.
 190     if (StrLength-1 > CAT->getSize().getZExtValue())
 191       S.Diag(Str->getLocStart(),
 192              diag::ext_initializer_string_for_char_array_too_long)
 193         << Str->getSourceRange();
 194   }
 195
 196   // Set the type to the actual size that we are initializing.  If we have
 197   // something like:
 198   //   char x[1] = "foo";
 199   // then this will set the string literal's type to char[1].
 200   updateStringLiteralType(Str, DeclT);
 201 }
 202
 203 //===----------------------------------------------------------------------===//
 204 // Semantic checking for initializer lists.
 205 //===----------------------------------------------------------------------===//
 206
 207 namespace {
 208
 209 /// @brief Semantic checking for initializer lists.
 210 ///
 211 /// The InitListChecker class contains a set of routines that each
 212 /// handle the initialization of a certain kind of entity, e.g.,
 213 /// arrays, vectors, struct/union types, scalars, etc. The
 214 /// InitListChecker itself performs a recursive walk of the subobject
 215 /// structure of the type to be initialized, while stepping through
 216 /// the initializer list one element at a time. The IList and Index
 217 /// parameters to each of the Check* routines contain the active
 218 /// (syntactic) initializer list and the index into that initializer
 219 /// list that represents the current initializer. Each routine is
 220 /// responsible for moving that Index forward as it consumes elements.
 221 ///
 222 /// Each Check* routine also has a StructuredList/StructuredIndex
 223 /// arguments, which contains the current "structured" (semantic)
 224 /// initializer list and the index into that initializer list where we
 225 /// are copying initializers as we map them over to the semantic
 226 /// list. Once we have completed our recursive walk of the subobject
 227 /// structure, we will have constructed a full semantic initializer
 228 /// list.
 229 ///
 230 /// C99 designators cause changes in the initializer list traversal,
 231 /// because they make the initialization "jump" into a specific
 232 /// subobject and then continue the initialization from that
 233 /// point. CheckDesignatedInitializer() recursively steps into the
 234 /// designated subobject and manages backing out the recursion to
 235 /// initialize the subobjects after the one designated.
 236 class InitListChecker {
 237   Sema &SemaRef;
 238   bool hadError;
 239   bool VerifyOnly; // no diagnostics, no structure building
 240   bool TreatUnavailableAsInvalid; // Used only in VerifyOnly mode.
 241   llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic;
 242   InitListExpr *FullyStructuredList;
 243
 244   void CheckImplicitInitList(const InitializedEntity &Entity,
 245                              InitListExpr *ParentIList, QualType T,
 246                              unsigned &Index, InitListExpr *StructuredList,
 247                              unsigned &StructuredIndex);
 248   void CheckExplicitInitList(const InitializedEntity &Entity,
 249                              InitListExpr *IList, QualType &T,
 250                              InitListExpr *StructuredList,
 251                              bool TopLevelObject = false);
 252   void CheckListElementTypes(const InitializedEntity &Entity,
 253                              InitListExpr *IList, QualType &DeclType,
 254                              bool SubobjectIsDesignatorContext,
 255                              unsigned &Index,
 256                              InitListExpr *StructuredList,
 257                              unsigned &StructuredIndex,
 258                              bool TopLevelObject = false);
 259   void CheckSubElementType(const InitializedEntity &Entity,
 260                            InitListExpr *IList, QualType ElemType,
 261                            unsigned &Index,
 262                            InitListExpr *StructuredList,
 263                            unsigned &StructuredIndex);
 264   void CheckComplexType(const InitializedEntity &Entity,
 265                         InitListExpr *IList, QualType DeclType,
 266                         unsigned &Index,
 267                         InitListExpr *StructuredList,
 268                         unsigned &StructuredIndex);
 269   void CheckScalarType(const InitializedEntity &Entity,
 270                        InitListExpr *IList, QualType DeclType,
 271                        unsigned &Index,
 272                        InitListExpr *StructuredList,
 273                        unsigned &StructuredIndex);
 274   void CheckReferenceType(const InitializedEntity &Entity,
 275                           InitListExpr *IList, QualType DeclType,
 276                           unsigned &Index,
 277                           InitListExpr *StructuredList,
 278                           unsigned &StructuredIndex);
 279   void CheckVectorType(const InitializedEntity &Entity,
 280                        InitListExpr *IList, QualType DeclType, unsigned &Index,
 281                        InitListExpr *StructuredList,
 282                        unsigned &StructuredIndex);
 283   void CheckStructUnionTypes(const InitializedEntity &Entity,
 284                              InitListExpr *IList, QualType DeclType,
 285                              CXXRecordDecl::base_class_range Bases,
 286                              RecordDecl::field_iterator Field,
 287                              bool SubobjectIsDesignatorContext, unsigned &Index,
 288                              InitListExpr *StructuredList,
 289                              unsigned &StructuredIndex,
 290                              bool TopLevelObject = false);
 291   void CheckArrayType(const InitializedEntity &Entity,
 292                       InitListExpr *IList, QualType &DeclType,
 293                       llvm::APSInt elementIndex,
 294                       bool SubobjectIsDesignatorContext, unsigned &Index,
 295                       InitListExpr *StructuredList,
 296                       unsigned &StructuredIndex);
 297   bool CheckDesignatedInitializer(const InitializedEntity &Entity,
 298                                   InitListExpr *IList, DesignatedInitExpr *DIE,
 299                                   unsigned DesigIdx,
 300                                   QualType &CurrentObjectType,
 301                                   RecordDecl::field_iterator *NextField,
 302                                   llvm::APSInt *NextElementIndex,
 303                                   unsigned &Index,
 304                                   InitListExpr *StructuredList,
 305                                   unsigned &StructuredIndex,
 306                                   bool FinishSubobjectInit,
 307                                   bool TopLevelObject);
 308   InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
 309                                            QualType CurrentObjectType,
 310                                            InitListExpr *StructuredList,
 311                                            unsigned StructuredIndex,
 312                                            SourceRange InitRange,
 313                                            bool IsFullyOverwritten = false);
 314   void UpdateStructuredListElement(InitListExpr *StructuredList,
 315                                    unsigned &StructuredIndex,
 316                                    Expr *expr);
 317   int numArrayElements(QualType DeclType);
 318   int numStructUnionElements(QualType DeclType);
 319
 320   static ExprResult PerformEmptyInit(Sema &SemaRef,
 321                                      SourceLocation Loc,
 322                                      const InitializedEntity &Entity,
 323                                      bool VerifyOnly,
 324                                      bool TreatUnavailableAsInvalid);
 325
 326   // Explanation on the "FillWithNoInit" mode:
 327   //
 328   // Assume we have the following definitions (Case#1):
 329   // struct P { char x[6][6]; } xp = { .x[1] = "bar" };
 330   // struct PP { struct P lp; } l = { .lp = xp, .lp.x[1][2] = 'f' };
 331   //
 332   // l.lp.x[1][0..1] should not be filled with implicit initializers because the
 333   // "base" initializer "xp" will provide values for them; l.lp.x[1] will be "baf".
 334   //
 335   // But if we have (Case#2):
 336   // struct PP l = { .lp = xp, .lp.x[1] = { [2] = 'f' } };
 337   //
 338   // l.lp.x[1][0..1] are implicitly initialized and do not use values from the
 339   // "base" initializer; l.lp.x[1] will be "\0\0f\0\0\0".
 340   //
 341   // To distinguish Case#1 from Case#2, and also to avoid leaving many "holes"
 342   // in the InitListExpr, the "holes" in Case#1 are filled not with empty
 343   // initializers but with special "NoInitExpr" place holders, which tells the
 344   // CodeGen not to generate any initializers for these parts.
 345   void FillInEmptyInitForBase(unsigned Init, const CXXBaseSpecifier &Base,
 346                               const InitializedEntity &ParentEntity,
 347                               InitListExpr *ILE, bool &RequiresSecondPass,
 348                               bool FillWithNoInit);
 349   void FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
 350                                const InitializedEntity &ParentEntity,
 351                                InitListExpr *ILE, bool &RequiresSecondPass,
 352                                bool FillWithNoInit = false);
 353   void FillInEmptyInitializations(const InitializedEntity &Entity,
 354                                   InitListExpr *ILE, bool &RequiresSecondPass,
 355                                   bool FillWithNoInit = false);
 356   bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
 357                               Expr *InitExpr, FieldDecl *Field,
 358                               bool TopLevelObject);
 359   void CheckEmptyInitializable(const InitializedEntity &Entity,
 360                                SourceLocation Loc);
 361
 362 public:
 363   InitListChecker(Sema &S, const InitializedEntity &Entity,
 364                   InitListExpr *IL, QualType &T, bool VerifyOnly,
 365                   bool TreatUnavailableAsInvalid);
 366   bool HadError() { return hadError; }
 367
 368   // @brief Retrieves the fully-structured initializer list used for
 369   // semantic analysis and code generation.
 370   InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
 371 };
 372
 373 } // end anonymous namespace
 374
 375 ExprResult InitListChecker::PerformEmptyInit(Sema &SemaRef,
 376                                              SourceLocation Loc,
 377                                              const InitializedEntity &Entity,
 378                                              bool VerifyOnly,
 379                                              bool TreatUnavailableAsInvalid) {
 380   InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
 381                                                             true);
 382   MultiExprArg SubInit;
 383   Expr *InitExpr;
 384   InitListExpr DummyInitList(SemaRef.Context, Loc, None, Loc);
 385
 386   // C++ [dcl.init.aggr]p7:
 387   //   If there are fewer initializer-clauses in the list than there are
 388   //   members in the aggregate, then each member not explicitly initialized
 389   //   ...
 390   bool EmptyInitList = SemaRef.getLangOpts().CPlusPlus11 &&
 391       Entity.getType()->getBaseElementTypeUnsafe()->isRecordType();
 392   if (EmptyInitList) {
 393     // C++1y / DR1070:
 394     //   shall be initialized [...] from an empty initializer list.
 395     //
 396     // We apply the resolution of this DR to C++11 but not C++98, since C++98
 397     // does not have useful semantics for initialization from an init list.
 398     // We treat this as copy-initialization, because aggregate initialization
 399     // always performs copy-initialization on its elements.
 400     //
 401     // Only do this if we're initializing a class type, to avoid filling in
 402     // the initializer list where possible.
 403     InitExpr = VerifyOnly ? &DummyInitList : new (SemaRef.Context)
 404                    InitListExpr(SemaRef.Context, Loc, None, Loc);
 405     InitExpr->setType(SemaRef.Context.VoidTy);
 406     SubInit = InitExpr;
 407     Kind = InitializationKind::CreateCopy(Loc, Loc);
 408   } else {
 409     // C++03:
 410     //   shall be value-initialized.
 411   }
 412
 413   InitializationSequence InitSeq(SemaRef, Entity, Kind, SubInit);
 414   // libstdc++4.6 marks the vector default constructor as explicit in
 415   // _GLIBCXX_DEBUG mode, so recover using the C++03 logic in that case.
 416   // stlport does so too. Look for std::__debug for libstdc++, and for
 417   // std:: for stlport.  This is effectively a compiler-side implementation of
 418   // LWG2193.
 419   if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
 420           InitializationSequence::FK_ExplicitConstructor) {
 421     OverloadCandidateSet::iterator Best;
 422     OverloadingResult O =
 423         InitSeq.getFailedCandidateSet()
 424             .BestViableFunction(SemaRef, Kind.getLocation(), Best);
 425     (void)O;
 426     assert(O == OR_Success && "Inconsistent overload resolution");
 427     CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
 428     CXXRecordDecl *R = CtorDecl->getParent();
 429
 430     if (CtorDecl->getMinRequiredArguments() == 0 &&
 431         CtorDecl->isExplicit() && R->getDeclName() &&
 432         SemaRef.SourceMgr.isInSystemHeader(CtorDecl->getLocation())) {
 433       bool IsInStd = false;
 434       for (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(R->getDeclContext());
 435            ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
 436         if (SemaRef.getStdNamespace()->InEnclosingNamespaceSetOf(ND))
 437           IsInStd = true;
 438       }
 439
 440       if (IsInStd && llvm::StringSwitch<bool>(R->getName())
 441               .Cases("basic_string", "deque", "forward_list", true)
 442               .Cases("list", "map", "multimap", "multiset", true)
 443               .Cases("priority_queue", "queue", "set", "stack", true)
 444               .Cases("unordered_map", "unordered_set", "vector", true)
 445               .Default(false)) {
 446         InitSeq.InitializeFrom(
 447             SemaRef, Entity,
 448             InitializationKind::CreateValue(Loc, Loc, Loc, true),
 449             MultiExprArg(), /*TopLevelOfInitList=*/false,
 450             TreatUnavailableAsInvalid);
 451         // Emit a warning for this.  System header warnings aren't shown
 452         // by default, but people working on system headers should see it.
 453         if (!VerifyOnly) {
 454           SemaRef.Diag(CtorDecl->getLocation(),
 455                        diag::warn_invalid_initializer_from_system_header);
 456           if (Entity.getKind() == InitializedEntity::EK_Member)
 457             SemaRef.Diag(Entity.getDecl()->getLocation(),
 458                          diag::note_used_in_initialization_here);
 459           else if (Entity.getKind() == InitializedEntity::EK_ArrayElement)
 460             SemaRef.Diag(Loc, diag::note_used_in_initialization_here);
 461         }
 462       }
 463     }
 464   }
 465   if (!InitSeq) {
 466     if (!VerifyOnly) {
 467       InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
 468       if (Entity.getKind() == InitializedEntity::EK_Member)
 469         SemaRef.Diag(Entity.getDecl()->getLocation(),
 470                      diag::note_in_omitted_aggregate_initializer)
 471           << /*field*/1 << Entity.getDecl();
 472       else if (Entity.getKind() == InitializedEntity::EK_ArrayElement) {
 473         bool IsTrailingArrayNewMember =
 474             Entity.getParent() &&
 475             Entity.getParent()->isVariableLengthArrayNew();
 476         SemaRef.Diag(Loc, diag::note_in_omitted_aggregate_initializer)
 477           << (IsTrailingArrayNewMember ? 2 : /*array element*/0)
 478           << Entity.getElementIndex();
 479       }
 480     }
 481     return ExprError();
 482   }
 483
 484   return VerifyOnly ? ExprResult(static_cast<Expr *>(nullptr))
 485                     : InitSeq.Perform(SemaRef, Entity, Kind, SubInit);
 486 }
 487
 488 void InitListChecker::CheckEmptyInitializable(const InitializedEntity &Entity,
 489                                               SourceLocation Loc) {
 490   assert(VerifyOnly &&
 491          "CheckEmptyInitializable is only inteded for verification mode.");
 492   if (PerformEmptyInit(SemaRef, Loc, Entity, /*VerifyOnly*/true,
 493                        TreatUnavailableAsInvalid).isInvalid())
 494     hadError = true;
 495 }
 496
 497 void InitListChecker::FillInEmptyInitForBase(
 498     unsigned Init, const CXXBaseSpecifier &Base,
 499     const InitializedEntity &ParentEntity, InitListExpr *ILE,
 500     bool &RequiresSecondPass, bool FillWithNoInit) {
 501   assert(Init < ILE->getNumInits() && "should have been expanded");
 502
 503   InitializedEntity BaseEntity = InitializedEntity::InitializeBase(
 504       SemaRef.Context, &Base, false, &ParentEntity);
 505
 506   if (!ILE->getInit(Init)) {
 507     ExprResult BaseInit =
 508         FillWithNoInit ? new (SemaRef.Context) NoInitExpr(Base.getType())
 509                        : PerformEmptyInit(SemaRef, ILE->getLocEnd(), BaseEntity,
 510                                           /*VerifyOnly*/ false,
 511                                           TreatUnavailableAsInvalid);
 512     if (BaseInit.isInvalid()) {
 513       hadError = true;
 514       return;
 515     }
 516
 517     ILE->setInit(Init, BaseInit.getAs<Expr>());
 518   } else if (InitListExpr *InnerILE =
 519                  dyn_cast<InitListExpr>(ILE->getInit(Init))) {
 520     FillInEmptyInitializations(BaseEntity, InnerILE,
 521                                RequiresSecondPass, FillWithNoInit);
 522   } else if (DesignatedInitUpdateExpr *InnerDIUE =
 523                dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init))) {
 524     FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),
 525                                RequiresSecondPass, /*FillWithNoInit =*/true);
 526   }
 527 }
 528
 529 void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
 530                                         const InitializedEntity &ParentEntity,
 531                                               InitListExpr *ILE,
 532                                               bool &RequiresSecondPass,
 533                                               bool FillWithNoInit) {
 534   SourceLocation Loc = ILE->getLocEnd();
 535   unsigned NumInits = ILE->getNumInits();
 536   InitializedEntity MemberEntity
 537     = InitializedEntity::InitializeMember(Field, &ParentEntity);
 538
 539   if (const RecordType *RType = ILE->getType()->getAs<RecordType>())
 540     if (!RType->getDecl()->isUnion())
 541       assert(Init < NumInits && "This ILE should have been expanded");
 542
 543   if (Init >= NumInits || !ILE->getInit(Init)) {
 544     if (FillWithNoInit) {
 545       Expr *Filler = new (SemaRef.Context) NoInitExpr(Field->getType());
 546       if (Init < NumInits)
 547         ILE->setInit(Init, Filler);
 548       else
 549         ILE->updateInit(SemaRef.Context, Init, Filler);
 550       return;
 551     }
 552     // C++1y [dcl.init.aggr]p7:
 553     //   If there are fewer initializer-clauses in the list than there are
 554     //   members in the aggregate, then each member not explicitly initialized
 555     //   shall be initialized from its brace-or-equal-initializer [...]
 556     if (Field->hasInClassInitializer()) {
 557       ExprResult DIE = SemaRef.BuildCXXDefaultInitExpr(Loc, Field);
 558       if (DIE.isInvalid()) {
 559         hadError = true;
 560         return;
 561       }
 562       if (Init < NumInits)
 563         ILE->setInit(Init, DIE.get());
 564       else {
 565         ILE->updateInit(SemaRef.Context, Init, DIE.get());
 566         RequiresSecondPass = true;
 567       }
 568       return;
 569     }
 570
 571     if (Field->getType()->isReferenceType()) {
 572       // C++ [dcl.init.aggr]p9:
 573       //   If an incomplete or empty initializer-list leaves a
 574       //   member of reference type uninitialized, the program is
 575       //   ill-formed.
 576       SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
 577         << Field->getType()
 578         << ILE->getSyntacticForm()->getSourceRange();
 579       SemaRef.Diag(Field->getLocation(),
 580                    diag::note_uninit_reference_member);
 581       hadError = true;
 582       return;
 583     }
 584
 585     ExprResult MemberInit = PerformEmptyInit(SemaRef, Loc, MemberEntity,
 586                                              /*VerifyOnly*/false,
 587                                              TreatUnavailableAsInvalid);
 588     if (MemberInit.isInvalid()) {
 589       hadError = true;
 590       return;
 591     }
 592
 593     if (hadError) {
 594       // Do nothing
 595     } else if (Init < NumInits) {
 596       ILE->setInit(Init, MemberInit.getAs<Expr>());
 597     } else if (!isa<ImplicitValueInitExpr>(MemberInit.get())) {
 598       // Empty initialization requires a constructor call, so
 599       // extend the initializer list to include the constructor
 600       // call and make a note that we'll need to take another pass
 601       // through the initializer list.
 602       ILE->updateInit(SemaRef.Context, Init, MemberInit.getAs<Expr>());
 603       RequiresSecondPass = true;
 604     }
 605   } else if (InitListExpr *InnerILE
 606                = dyn_cast<InitListExpr>(ILE->getInit(Init)))
 607     FillInEmptyInitializations(MemberEntity, InnerILE,
 608                                RequiresSecondPass, FillWithNoInit);
 609   else if (DesignatedInitUpdateExpr *InnerDIUE
 610                = dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init)))
 611     FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
 612                                RequiresSecondPass, /*FillWithNoInit =*/ true);
 613 }
 614
 615 /// Recursively replaces NULL values within the given initializer list
 616 /// with expressions that perform value-initialization of the
 617 /// appropriate type.
 618 void
 619 InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity,
 620                                             InitListExpr *ILE,
 621                                             bool &RequiresSecondPass,
 622                                             bool FillWithNoInit) {
 623   assert((ILE->getType() != SemaRef.Context.VoidTy) &&
 624          "Should not have void type");
 625
 626   if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
 627     const RecordDecl *RDecl = RType->getDecl();
 628     if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())
 629       FillInEmptyInitForField(0, ILE->getInitializedFieldInUnion(),
 630                               Entity, ILE, RequiresSecondPass, FillWithNoInit);
 631     else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
 632              cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
 633       for (auto *Field : RDecl->fields()) {
 634         if (Field->hasInClassInitializer()) {
 635           FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass,
 636                                   FillWithNoInit);
 637           break;
 638         }
 639       }
 640     } else {
 641       // The fields beyond ILE->getNumInits() are default initialized, so in
 642       // order to leave them uninitialized, the ILE is expanded and the extra
 643       // fields are then filled with NoInitExpr.
 644       unsigned NumElems = numStructUnionElements(ILE->getType());
 645       if (RDecl->hasFlexibleArrayMember())
 646         ++NumElems;
 647       if (ILE->getNumInits() < NumElems)
 648         ILE->resizeInits(SemaRef.Context, NumElems);
 649
 650       unsigned Init = 0;
 651
 652       if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {
 653         for (auto &Base : CXXRD->bases()) {
 654           if (hadError)
 655             return;
 656
 657           FillInEmptyInitForBase(Init, Base, Entity, ILE, RequiresSecondPass,
 658                                  FillWithNoInit);
 659           ++Init;
 660         }
 661       }
 662
 663       for (auto *Field : RDecl->fields()) {
 664         if (Field->isUnnamedBitfield())
 665           continue;
 666
 667         if (hadError)
 668           return;
 669
 670         FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass,
 671                                 FillWithNoInit);
 672         if (hadError)
 673           return;
 674
 675         ++Init;
 676
 677         // Only look at the first initialization of a union.
 678         if (RDecl->isUnion())
 679           break;
 680       }
 681     }
 682
 683     return;
 684   }
 685
 686   QualType ElementType;
 687
 688   InitializedEntity ElementEntity = Entity;
 689   unsigned NumInits = ILE->getNumInits();
 690   unsigned NumElements = NumInits;
 691   if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
 692     ElementType = AType->getElementType();
 693     if (const auto *CAType = dyn_cast<ConstantArrayType>(AType))
 694       NumElements = CAType->getSize().getZExtValue();
 695     // For an array new with an unknown bound, ask for one additional element
 696     // in order to populate the array filler.
 697     if (Entity.isVariableLengthArrayNew())
 698       ++NumElements;
 699     ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
 700                                                          0, Entity);
 701   } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
 702     ElementType = VType->getElementType();
 703     NumElements = VType->getNumElements();
 704     ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
 705                                                          0, Entity);
 706   } else
 707     ElementType = ILE->getType();
 708
 709   for (unsigned Init = 0; Init != NumElements; ++Init) {
 710     if (hadError)
 711       return;
 712
 713     if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
 714         ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
 715       ElementEntity.setElementIndex(Init);
 716
 717     Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr);
 718     if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
 719       ILE->setInit(Init, ILE->getArrayFiller());
 720     else if (!InitExpr && !ILE->hasArrayFiller()) {
 721       Expr *Filler = nullptr;
 722
 723       if (FillWithNoInit)
 724         Filler = new (SemaRef.Context) NoInitExpr(ElementType);
 725       else {
 726         ExprResult ElementInit = PerformEmptyInit(SemaRef, ILE->getLocEnd(),
 727                                                   ElementEntity,
 728                                                   /*VerifyOnly*/false,
 729                                                   TreatUnavailableAsInvalid);
 730         if (ElementInit.isInvalid()) {
 731           hadError = true;
 732           return;
 733         }
 734
 735         Filler = ElementInit.getAs<Expr>();
 736       }
 737
 738       if (hadError) {
 739         // Do nothing
 740       } else if (Init < NumInits) {
 741         // For arrays, just set the expression used for value-initialization
 742         // of the "holes" in the array.
 743         if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
 744           ILE->setArrayFiller(Filler);
 745         else
 746           ILE->setInit(Init, Filler);
 747       } else {
 748         // For arrays, just set the expression used for value-initialization
 749         // of the rest of elements and exit.
 750         if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
 751           ILE->setArrayFiller(Filler);
 752           return;
 753         }
 754
 755         if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {
 756           // Empty initialization requires a constructor call, so
 757           // extend the initializer list to include the constructor
 758           // call and make a note that we'll need to take another pass
 759           // through the initializer list.
 760           ILE->updateInit(SemaRef.Context, Init, Filler);
 761           RequiresSecondPass = true;
 762         }
 763       }
 764     } else if (InitListExpr *InnerILE
 765                  = dyn_cast_or_null<InitListExpr>(InitExpr))
 766       FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
 767                                  FillWithNoInit);
 768     else if (DesignatedInitUpdateExpr *InnerDIUE
 769                  = dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr))
 770       FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
 771                                  RequiresSecondPass, /*FillWithNoInit =*/ true);
 772   }
 773 }
 774
 775 InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
 776                                  InitListExpr *IL, QualType &T,
 777                                  bool VerifyOnly,
 778                                  bool TreatUnavailableAsInvalid)
 779   : SemaRef(S), VerifyOnly(VerifyOnly),
 780     TreatUnavailableAsInvalid(TreatUnavailableAsInvalid) {
 781   // FIXME: Check that IL isn't already the semantic form of some other
 782   // InitListExpr. If it is, we'd create a broken AST.
 783
 784   hadError = false;
 785
 786   FullyStructuredList =
 787       getStructuredSubobjectInit(IL, 0, T, nullptr, 0, IL->getSourceRange());
 788   CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
 789                         /*TopLevelObject=*/true);
 790
 791   if (!hadError && !VerifyOnly) {
 792     bool RequiresSecondPass = false;
 793     FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass);
 794     if (RequiresSecondPass && !hadError)
 795       FillInEmptyInitializations(Entity, FullyStructuredList,
 796                                  RequiresSecondPass);
 797   }
 798 }
 799
 800 int InitListChecker::numArrayElements(QualType DeclType) {
 801   // FIXME: use a proper constant
 802   int maxElements = 0x7FFFFFFF;
 803   if (const ConstantArrayType *CAT =
 804         SemaRef.Context.getAsConstantArrayType(DeclType)) {
 805     maxElements = static_cast<int>(CAT->getSize().getZExtValue());
 806   }
 807   return maxElements;
 808 }
 809
 810 int InitListChecker::numStructUnionElements(QualType DeclType) {
 811   RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
 812   int InitializableMembers = 0;
 813   if (auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl))
 814     InitializableMembers += CXXRD->getNumBases();
 815   for (const auto *Field : structDecl->fields())
 816     if (!Field->isUnnamedBitfield())
 817       ++InitializableMembers;
 818
 819   if (structDecl->isUnion())
 820     return std::min(InitializableMembers, 1);
 821   return InitializableMembers - structDecl->hasFlexibleArrayMember();
 822 }
 823
 824 /// Check whether the range of the initializer \p ParentIList from element
 825 /// \p Index onwards can be used to initialize an object of type \p T. Update
 826 /// \p Index to indicate how many elements of the list were consumed.
 827 ///
 828 /// This also fills in \p StructuredList, from element \p StructuredIndex
 829 /// onwards, with the fully-braced, desugared form of the initialization.
 830 void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
 831                                             InitListExpr *ParentIList,
 832                                             QualType T, unsigned &Index,
 833                                             InitListExpr *StructuredList,
 834                                             unsigned &StructuredIndex) {
 835   int maxElements = 0;
 836
 837   if (T->isArrayType())
 838     maxElements = numArrayElements(T);
 839   else if (T->isRecordType())
 840     maxElements = numStructUnionElements(T);
 841   else if (T->isVectorType())
 842     maxElements = T->getAs<VectorType>()->getNumElements();
 843   else
 844     llvm_unreachable("CheckImplicitInitList(): Illegal type");
 845
 846   if (maxElements == 0) {
 847     if (!VerifyOnly)
 848       SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
 849                    diag::err_implicit_empty_initializer);
 850     ++Index;
 851     hadError = true;
 852     return;
 853   }
 854
 855   // Build a structured initializer list corresponding to this subobject.
 856   InitListExpr *StructuredSubobjectInitList
 857     = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
 858                                  StructuredIndex,
 859           SourceRange(ParentIList->getInit(Index)->getLocStart(),
 860                       ParentIList->getSourceRange().getEnd()));
 861   unsigned StructuredSubobjectInitIndex = 0;
 862
 863   // Check the element types and build the structural subobject.
 864   unsigned StartIndex = Index;
 865   CheckListElementTypes(Entity, ParentIList, T,
 866                         /*SubobjectIsDesignatorContext=*/false, Index,
 867                         StructuredSubobjectInitList,
 868                         StructuredSubobjectInitIndex);
 869
 870   if (!VerifyOnly) {
 871     StructuredSubobjectInitList->setType(T);
 872
 873     unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
 874     // Update the structured sub-object initializer so that it's ending
 875     // range corresponds with the end of the last initializer it used.
 876     if (EndIndex < ParentIList->getNumInits() &&
 877         ParentIList->getInit(EndIndex)) {
 878       SourceLocation EndLoc
 879         = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
 880       StructuredSubobjectInitList->setRBraceLoc(EndLoc);
 881     }
 882
 883     // Complain about missing braces.
 884     if (T->isArrayType() || T->isRecordType()) {
 885       SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
 886                    diag::warn_missing_braces)
 887           << StructuredSubobjectInitList->getSourceRange()
 888           << FixItHint::CreateInsertion(
 889                  StructuredSubobjectInitList->getLocStart(), "{")
 890           << FixItHint::CreateInsertion(
 891                  SemaRef.getLocForEndOfToken(
 892                      StructuredSubobjectInitList->getLocEnd()),
 893                  "}");
 894     }
 895   }
 896 }
 897
 898 /// Warn that \p Entity was of scalar type and was initialized by a
 899 /// single-element braced initializer list.
 900 static void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity,
 901                                  SourceRange Braces) {
 902   // Don't warn during template instantiation. If the initialization was
 903   // non-dependent, we warned during the initial parse; otherwise, the
 904   // type might not be scalar in some uses of the template.
 905   if (!S.ActiveTemplateInstantiations.empty())
 906     return;
 907
 908   unsigned DiagID = 0;
 909
 910   switch (Entity.getKind()) {
 911   case InitializedEntity::EK_VectorElement:
 912   case InitializedEntity::EK_ComplexElement:
 913   case InitializedEntity::EK_ArrayElement:
 914   case InitializedEntity::EK_Parameter:
 915   case InitializedEntity::EK_Parameter_CF_Audited:
 916   case InitializedEntity::EK_Result:
 917     // Extra braces here are suspicious.
 918     DiagID = diag::warn_braces_around_scalar_init;
 919     break;
 920
 921   case InitializedEntity::EK_Member:
 922     // Warn on aggregate initialization but not on ctor init list or
 923     // default member initializer.
 924     if (Entity.getParent())
 925       DiagID = diag::warn_braces_around_scalar_init;
 926     break;
 927
 928   case InitializedEntity::EK_Variable:
 929   case InitializedEntity::EK_LambdaCapture:
 930     // No warning, might be direct-list-initialization.
 931     // FIXME: Should we warn for copy-list-initialization in these cases?
 932     break;
 933
 934   case InitializedEntity::EK_New:
 935   case InitializedEntity::EK_Temporary:
 936   case InitializedEntity::EK_CompoundLiteralInit:
 937     // No warning, braces are part of the syntax of the underlying construct.
 938     break;
 939
 940   case InitializedEntity::EK_RelatedResult:
 941     // No warning, we already warned when initializing the result.
 942     break;
 943
 944   case InitializedEntity::EK_Exception:
 945   case InitializedEntity::EK_Base:
 946   case InitializedEntity::EK_Delegating:
 947   case InitializedEntity::EK_BlockElement:
 948   case InitializedEntity::EK_Binding:
 949     llvm_unreachable("unexpected braced scalar init");
 950   }
 951
 952   if (DiagID) {
 953     S.Diag(Braces.getBegin(), DiagID)
 954       << Braces
 955       << FixItHint::CreateRemoval(Braces.getBegin())
 956       << FixItHint::CreateRemoval(Braces.getEnd());
 957   }
 958 }
 959
 960 /// Check whether the initializer \p IList (that was written with explicit
 961 /// braces) can be used to initialize an object of type \p T.
 962 ///
 963 /// This also fills in \p StructuredList with the fully-braced, desugared
 964 /// form of the initialization.
 965 void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
 966                                             InitListExpr *IList, QualType &T,
 967                                             InitListExpr *StructuredList,
 968                                             bool TopLevelObject) {
 969   if (!VerifyOnly) {
 970     SyntacticToSemantic[IList] = StructuredList;
 971     StructuredList->setSyntacticForm(IList);
 972   }
 973
 974   unsigned Index = 0, StructuredIndex = 0;
 975   CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
 976                         Index, StructuredList, StructuredIndex, TopLevelObject);
 977   if (!VerifyOnly) {
 978     QualType ExprTy = T;
 979     if (!ExprTy->isArrayType())
 980       ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context);
 981     IList->setType(ExprTy);
 982     StructuredList->setType(ExprTy);
 983   }
 984   if (hadError)
 985     return;
 986
 987   if (Index < IList->getNumInits()) {
 988     // We have leftover initializers
 989     if (VerifyOnly) {
 990       if (SemaRef.getLangOpts().CPlusPlus ||
 991           (SemaRef.getLangOpts().OpenCL &&
 992            IList->getType()->isVectorType())) {
 993         hadError = true;
 994       }
 995       return;
 996     }
 997
 998     if (StructuredIndex == 1 &&
 999         IsStringInit(StructuredList->getInit(0), T, SemaRef.Context) ==
1000             SIF_None) {
1001       unsigned DK = diag::ext_excess_initializers_in_char_array_initializer;
1002       if (SemaRef.getLangOpts().CPlusPlus) {
1003         DK = diag::err_excess_initializers_in_char_array_initializer;
1004         hadError = true;
1005       }
1006       // Special-case
1007       SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
1008         << IList->getInit(Index)->getSourceRange();
1009     } else if (!T->isIncompleteType()) {
1010       // Don't complain for incomplete types, since we'll get an error
1011       // elsewhere
1012       QualType CurrentObjectType = StructuredList->getType();
1013       int initKind =
1014         CurrentObjectType->isArrayType()? 0 :
1015         CurrentObjectType->isVectorType()? 1 :
1016         CurrentObjectType->isScalarType()? 2 :
1017         CurrentObjectType->isUnionType()? 3 :
1018         4;
1019
1020       unsigned DK = diag::ext_excess_initializers;
1021       if (SemaRef.getLangOpts().CPlusPlus) {
1022         DK = diag::err_excess_initializers;
1023         hadError = true;
1024       }
1025       if (SemaRef.getLangOpts().OpenCL && initKind == 1) {
1026         DK = diag::err_excess_initializers;
1027         hadError = true;
1028       }
1029
1030       SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
1031         << initKind << IList->getInit(Index)->getSourceRange();
1032     }
1033   }
1034
1035   if (!VerifyOnly && T->isScalarType() &&
1036       IList->getNumInits() == 1 && !isa<InitListExpr>(IList->getInit(0)))
1037     warnBracedScalarInit(SemaRef, Entity, IList->getSourceRange());
1038 }
1039
1040 void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
1041                                             InitListExpr *IList,
1042                                             QualType &DeclType,
1043                                             bool SubobjectIsDesignatorContext,
1044                                             unsigned &Index,
1045                                             InitListExpr *StructuredList,
1046                                             unsigned &StructuredIndex,
1047                                             bool TopLevelObject) {
1048   if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
1049     // Explicitly braced initializer for complex type can be real+imaginary
1050     // parts.
1051     CheckComplexType(Entity, IList, DeclType, Index,
1052                      StructuredList, StructuredIndex);
1053   } else if (DeclType->isScalarType()) {
1054     CheckScalarType(Entity, IList, DeclType, Index,
1055                     StructuredList, StructuredIndex);
1056   } else if (DeclType->isVectorType()) {
1057     CheckVectorType(Entity, IList, DeclType, Index,
1058                     StructuredList, StructuredIndex);
1059   } else if (DeclType->isRecordType()) {
1060     assert(DeclType->isAggregateType() &&
1061            "non-aggregate records should be handed in CheckSubElementType");
1062     RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1063     auto Bases =
1064         CXXRecordDecl::base_class_range(CXXRecordDecl::base_class_iterator(),
1065                                         CXXRecordDecl::base_class_iterator());
1066     if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1067       Bases = CXXRD->bases();
1068     CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(),
1069                           SubobjectIsDesignatorContext, Index, StructuredList,
1070                           StructuredIndex, TopLevelObject);
1071   } else if (DeclType->isArrayType()) {
1072     llvm::APSInt Zero(
1073                     SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
1074                     false);
1075     CheckArrayType(Entity, IList, DeclType, Zero,
1076                    SubobjectIsDesignatorContext, Index,
1077                    StructuredList, StructuredIndex);
1078   } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
1079     // This type is invalid, issue a diagnostic.
1080     ++Index;
1081     if (!VerifyOnly)
1082       SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
1083         << DeclType;
1084     hadError = true;
1085   } else if (DeclType->isReferenceType()) {
1086     CheckReferenceType(Entity, IList, DeclType, Index,
1087                        StructuredList, StructuredIndex);
1088   } else if (DeclType->isObjCObjectType()) {
1089     if (!VerifyOnly)
1090       SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
1091         << DeclType;
1092     hadError = true;
1093   } else {
1094     if (!VerifyOnly)
1095       SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
1096         << DeclType;
1097     hadError = true;
1098   }
1099 }
1100
1101 void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
1102                                           InitListExpr *IList,
1103                                           QualType ElemType,
1104                                           unsigned &Index,
1105                                           InitListExpr *StructuredList,
1106                                           unsigned &StructuredIndex) {
1107   Expr *expr = IList->getInit(Index);
1108
1109   if (ElemType->isReferenceType())
1110     return CheckReferenceType(Entity, IList, ElemType, Index,
1111                               StructuredList, StructuredIndex);
1112
1113   if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
1114     if (SubInitList->getNumInits() == 1 &&
1115         IsStringInit(SubInitList->getInit(0), ElemType, SemaRef.Context) ==
1116         SIF_None) {
1117       expr = SubInitList->getInit(0);
1118     } else if (!SemaRef.getLangOpts().CPlusPlus) {
1119       InitListExpr *InnerStructuredList
1120         = getStructuredSubobjectInit(IList, Index, ElemType,
1121                                      StructuredList, StructuredIndex,
1122                                      SubInitList->getSourceRange(), true);
1123       CheckExplicitInitList(Entity, SubInitList, ElemType,
1124                             InnerStructuredList);
1125
1126       if (!hadError && !VerifyOnly) {
1127         bool RequiresSecondPass = false;
1128         FillInEmptyInitializations(Entity, InnerStructuredList,
1129                                    RequiresSecondPass);
1130         if (RequiresSecondPass && !hadError)
1131           FillInEmptyInitializations(Entity, InnerStructuredList,
1132                                      RequiresSecondPass);
1133       }
1134       ++StructuredIndex;
1135       ++Index;
1136       return;
1137     }
1138     // C++ initialization is handled later.
1139   } else if (isa<ImplicitValueInitExpr>(expr)) {
1140     // This happens during template instantiation when we see an InitListExpr
1141     // that we've already checked once.
1142     assert(SemaRef.Context.hasSameType(expr->getType(), ElemType) &&
1143            "found implicit initialization for the wrong type");
1144     if (!VerifyOnly)
1145       UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1146     ++Index;
1147     return;
1148   }
1149
1150   if (SemaRef.getLangOpts().CPlusPlus) {
1151     // C++ [dcl.init.aggr]p2:
1152     //   Each member is copy-initialized from the corresponding
1153     //   initializer-clause.
1154
1155     // FIXME: Better EqualLoc?
1156     InitializationKind Kind =
1157       InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
1158     InitializationSequence Seq(SemaRef, Entity, Kind, expr,
1159                                /*TopLevelOfInitList*/ true);
1160
1161     // C++14 [dcl.init.aggr]p13:
1162     //   If the assignment-expression can initialize a member, the member is
1163     //   initialized. Otherwise [...] brace elision is assumed
1164     //
1165     // Brace elision is never performed if the element is not an
1166     // assignment-expression.
1167     if (Seq || isa<InitListExpr>(expr)) {
1168       if (!VerifyOnly) {
1169         ExprResult Result =
1170           Seq.Perform(SemaRef, Entity, Kind, expr);
1171         if (Result.isInvalid())
1172           hadError = true;
1173
1174         UpdateStructuredListElement(StructuredList, StructuredIndex,
1175                                     Result.getAs<Expr>());
1176       } else if (!Seq)
1177         hadError = true;
1178       ++Index;
1179       return;
1180     }
1181
1182     // Fall through for subaggregate initialization
1183   } else if (ElemType->isScalarType() || ElemType->isAtomicType()) {
1184     // FIXME: Need to handle atomic aggregate types with implicit init lists.
1185     return CheckScalarType(Entity, IList, ElemType, Index,
1186                            StructuredList, StructuredIndex);
1187   } else if (const ArrayType *arrayType =
1188                  SemaRef.Context.getAsArrayType(ElemType)) {
1189     // arrayType can be incomplete if we're initializing a flexible
1190     // array member.  There's nothing we can do with the completed
1191     // type here, though.
1192
1193     if (IsStringInit(expr, arrayType, SemaRef.Context) == SIF_None) {
1194       if (!VerifyOnly) {
1195         CheckStringInit(expr, ElemType, arrayType, SemaRef);
1196         UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1197       }
1198       ++Index;
1199       return;
1200     }
1201
1202     // Fall through for subaggregate initialization.
1203
1204   } else {
1205     assert((ElemType->isRecordType() || ElemType->isVectorType() ||
1206             ElemType->isClkEventT()) && "Unexpected type");
1207
1208     // C99 6.7.8p13:
1209     //
1210     //   The initializer for a structure or union object that has
1211     //   automatic storage duration shall be either an initializer
1212     //   list as described below, or a single expression that has
1213     //   compatible structure or union type. In the latter case, the
1214     //   initial value of the object, including unnamed members, is
1215     //   that of the expression.
1216     ExprResult ExprRes = expr;
1217     if (SemaRef.CheckSingleAssignmentConstraints(
1218             ElemType, ExprRes, !VerifyOnly) != Sema::Incompatible) {
1219       if (ExprRes.isInvalid())
1220         hadError = true;
1221       else {
1222         ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.get());
1223           if (ExprRes.isInvalid())
1224             hadError = true;
1225       }
1226       UpdateStructuredListElement(StructuredList, StructuredIndex,
1227                                   ExprRes.getAs<Expr>());
1228       ++Index;
1229       return;
1230     }
1231     ExprRes.get();
1232     // Fall through for subaggregate initialization
1233   }
1234
1235   // C++ [dcl.init.aggr]p12:
1236   //
1237   //   [...] Otherwise, if the member is itself a non-empty
1238   //   subaggregate, brace elision is assumed and the initializer is
1239   //   considered for the initialization of the first member of
1240   //   the subaggregate.
1241   // OpenCL vector initializer is handled elsewhere.
1242   if ((!SemaRef.getLangOpts().OpenCL && ElemType->isVectorType()) ||
1243       ElemType->isAggregateType()) {
1244     CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
1245                           StructuredIndex);
1246     ++StructuredIndex;
1247   } else {
1248     if (!VerifyOnly) {
1249       // We cannot initialize this element, so let
1250       // PerformCopyInitialization produce the appropriate diagnostic.
1251       SemaRef.PerformCopyInitialization(Entity, SourceLocation(), expr,
1252                                         /*TopLevelOfInitList=*/true);
1253     }
1254     hadError = true;
1255     ++Index;
1256     ++StructuredIndex;
1257   }
1258 }
1259
1260 void InitListChecker::CheckComplexType(const InitializedEntity &Entity,
1261                                        InitListExpr *IList, QualType DeclType,
1262                                        unsigned &Index,
1263                                        InitListExpr *StructuredList,
1264                                        unsigned &StructuredIndex) {
1265   assert(Index == 0 && "Index in explicit init list must be zero");
1266
1267   // As an extension, clang supports complex initializers, which initialize
1268   // a complex number component-wise.  When an explicit initializer list for
1269   // a complex number contains two two initializers, this extension kicks in:
1270   // it exepcts the initializer list to contain two elements convertible to
1271   // the element type of the complex type. The first element initializes
1272   // the real part, and the second element intitializes the imaginary part.
1273
1274   if (IList->getNumInits() != 2)
1275     return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1276                            StructuredIndex);
1277
1278   // This is an extension in C.  (The builtin _Complex type does not exist
1279   // in the C++ standard.)
1280   if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly)
1281     SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init)
1282       << IList->getSourceRange();
1283
1284   // Initialize the complex number.
1285   QualType elementType = DeclType->getAs<ComplexType>()->getElementType();
1286   InitializedEntity ElementEntity =
1287     InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1288
1289   for (unsigned i = 0; i < 2; ++i) {
1290     ElementEntity.setElementIndex(Index);
1291     CheckSubElementType(ElementEntity, IList, elementType, Index,
1292                         StructuredList, StructuredIndex);
1293   }
1294 }
1295
1296 void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
1297                                       InitListExpr *IList, QualType DeclType,
1298                                       unsigned &Index,
1299                                       InitListExpr *StructuredList,
1300                                       unsigned &StructuredIndex) {
1301   if (Index >= IList->getNumInits()) {
1302     if (!VerifyOnly)
1303       SemaRef.Diag(IList->getLocStart(),
1304                    SemaRef.getLangOpts().CPlusPlus11 ?
1305                      diag::warn_cxx98_compat_empty_scalar_initializer :
1306                      diag::err_empty_scalar_initializer)
1307         << IList->getSourceRange();
1308     hadError = !SemaRef.getLangOpts().CPlusPlus11;
1309     ++Index;
1310     ++StructuredIndex;
1311     return;
1312   }
1313
1314   Expr *expr = IList->getInit(Index);
1315   if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
1316     // FIXME: This is invalid, and accepting it causes overload resolution
1317     // to pick the wrong overload in some corner cases.
1318     if (!VerifyOnly)
1319       SemaRef.Diag(SubIList->getLocStart(),
1320                    diag::ext_many_braces_around_scalar_init)
1321         << SubIList->getSourceRange();
1322
1323     CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1324                     StructuredIndex);
1325     return;
1326   } else if (isa<DesignatedInitExpr>(expr)) {
1327     if (!VerifyOnly)
1328       SemaRef.Diag(expr->getLocStart(),
1329                    diag::err_designator_for_scalar_init)
1330         << DeclType << expr->getSourceRange();
1331     hadError = true;
1332     ++Index;
1333     ++StructuredIndex;
1334     return;
1335   }
1336
1337   if (VerifyOnly) {
1338     if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1339       hadError = true;
1340     ++Index;
1341     return;
1342   }
1343
1344   ExprResult Result =
1345     SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1346                                       /*TopLevelOfInitList=*/true);
1347
1348   Expr *ResultExpr = nullptr;
1349
1350   if (Result.isInvalid())
1351     hadError = true; // types weren't compatible.
1352   else {
1353     ResultExpr = Result.getAs<Expr>();
1354
1355     if (ResultExpr != expr) {
1356       // The type was promoted, update initializer list.
1357       IList->setInit(Index, ResultExpr);
1358     }
1359   }
1360   if (hadError)
1361     ++StructuredIndex;
1362   else
1363     UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1364   ++Index;
1365 }
1366
1367 void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
1368                                          InitListExpr *IList, QualType DeclType,
1369                                          unsigned &Index,
1370                                          InitListExpr *StructuredList,
1371                                          unsigned &StructuredIndex) {
1372   if (Index >= IList->getNumInits()) {
1373     // FIXME: It would be wonderful if we could point at the actual member. In
1374     // general, it would be useful to pass location information down the stack,
1375     // so that we know the location (or decl) of the "current object" being
1376     // initialized.
1377     if (!VerifyOnly)
1378       SemaRef.Diag(IList->getLocStart(),
1379                     diag::err_init_reference_member_uninitialized)
1380         << DeclType
1381         << IList->getSourceRange();
1382     hadError = true;
1383     ++Index;
1384     ++StructuredIndex;
1385     return;
1386   }
1387
1388   Expr *expr = IList->getInit(Index);
1389   if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) {
1390     if (!VerifyOnly)
1391       SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
1392         << DeclType << IList->getSourceRange();
1393     hadError = true;
1394     ++Index;
1395     ++StructuredIndex;
1396     return;
1397   }
1398
1399   if (VerifyOnly) {
1400     if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1401       hadError = true;
1402     ++Index;
1403     return;
1404   }
1405
1406   ExprResult Result =
1407       SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1408                                         /*TopLevelOfInitList=*/true);
1409
1410   if (Result.isInvalid())
1411     hadError = true;
1412
1413   expr = Result.getAs<Expr>();
1414   IList->setInit(Index, expr);
1415
1416   if (hadError)
1417     ++StructuredIndex;
1418   else
1419     UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1420   ++Index;
1421 }
1422
1423 void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
1424                                       InitListExpr *IList, QualType DeclType,
1425                                       unsigned &Index,
1426                                       InitListExpr *StructuredList,
1427                                       unsigned &StructuredIndex) {
1428   const VectorType *VT = DeclType->getAs<VectorType>();
1429   unsigned maxElements = VT->getNumElements();
1430   unsigned numEltsInit = 0;
1431   QualType elementType = VT->getElementType();
1432
1433   if (Index >= IList->getNumInits()) {
1434     // Make sure the element type can be value-initialized.
1435     if (VerifyOnly)
1436       CheckEmptyInitializable(
1437           InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity),
1438           IList->getLocEnd());
1439     return;
1440   }
1441
1442   if (!SemaRef.getLangOpts().OpenCL) {
1443     // If the initializing element is a vector, try to copy-initialize
1444     // instead of breaking it apart (which is doomed to failure anyway).
1445     Expr *Init = IList->getInit(Index);
1446     if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
1447       if (VerifyOnly) {
1448         if (!SemaRef.CanPerformCopyInitialization(Entity, Init))
1449           hadError = true;
1450         ++Index;
1451         return;
1452       }
1453
1454   ExprResult Result =
1455       SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(), Init,
1456                                         /*TopLevelOfInitList=*/true);
1457
1458       Expr *ResultExpr = nullptr;
1459       if (Result.isInvalid())
1460         hadError = true; // types weren't compatible.
1461       else {
1462         ResultExpr = Result.getAs<Expr>();
1463
1464         if (ResultExpr != Init) {
1465           // The type was promoted, update initializer list.
1466           IList->setInit(Index, ResultExpr);
1467         }
1468       }
1469       if (hadError)
1470         ++StructuredIndex;
1471       else
1472         UpdateStructuredListElement(StructuredList, StructuredIndex,
1473                                     ResultExpr);
1474       ++Index;
1475       return;
1476     }
1477
1478     InitializedEntity ElementEntity =
1479       InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1480
1481     for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1482       // Don't attempt to go past the end of the init list
1483       if (Index >= IList->getNumInits()) {
1484         if (VerifyOnly)
1485           CheckEmptyInitializable(ElementEntity, IList->getLocEnd());
1486         break;
1487       }
1488
1489       ElementEntity.setElementIndex(Index);
1490       CheckSubElementType(ElementEntity, IList, elementType, Index,
1491                           StructuredList, StructuredIndex);
1492     }
1493
1494     if (VerifyOnly)
1495       return;
1496
1497     bool isBigEndian = SemaRef.Context.getTargetInfo().isBigEndian();
1498     const VectorType *T = Entity.getType()->getAs<VectorType>();
1499     if (isBigEndian && (T->getVectorKind() == VectorType::NeonVector ||
1500                         T->getVectorKind() == VectorType::NeonPolyVector)) {
1501       // The ability to use vector initializer lists is a GNU vector extension
1502       // and is unrelated to the NEON intrinsics in arm_neon.h. On little
1503       // endian machines it works fine, however on big endian machines it
1504       // exhibits surprising behaviour:
1505       //
1506       //   uint32x2_t x = {42, 64};
1507       //   return vget_lane_u32(x, 0); // Will return 64.
1508       //
1509       // Because of this, explicitly call out that it is non-portable.
1510       //
1511       SemaRef.Diag(IList->getLocStart(),
1512                    diag::warn_neon_vector_initializer_non_portable);
1513
1514       const char *typeCode;
1515       unsigned typeSize = SemaRef.Context.getTypeSize(elementType);
1516
1517       if (elementType->isFloatingType())
1518         typeCode = "f";
1519       else if (elementType->isSignedIntegerType())
1520         typeCode = "s";
1521       else if (elementType->isUnsignedIntegerType())
1522         typeCode = "u";
1523       else
1524         llvm_unreachable("Invalid element type!");
1525
1526       SemaRef.Diag(IList->getLocStart(),
1527                    SemaRef.Context.getTypeSize(VT) > 64 ?
1528                    diag::note_neon_vector_initializer_non_portable_q :
1529                    diag::note_neon_vector_initializer_non_portable)
1530         << typeCode << typeSize;
1531     }
1532
1533     return;
1534   }
1535
1536   InitializedEntity ElementEntity =
1537     InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1538
1539   // OpenCL initializers allows vectors to be constructed from vectors.
1540   for (unsigned i = 0; i < maxElements; ++i) {
1541     // Don't attempt to go past the end of the init list
1542     if (Index >= IList->getNumInits())
1543       break;
1544
1545     ElementEntity.setElementIndex(Index);
1546
1547     QualType IType = IList->getInit(Index)->getType();
1548     if (!IType->isVectorType()) {
1549       CheckSubElementType(ElementEntity, IList, elementType, Index,
1550                           StructuredList, StructuredIndex);
1551       ++numEltsInit;
1552     } else {
1553       QualType VecType;
1554       const VectorType *IVT = IType->getAs<VectorType>();
1555       unsigned numIElts = IVT->getNumElements();
1556
1557       if (IType->isExtVectorType())
1558         VecType = SemaRef.Context.getExtVectorType(elementType, numIElts);
1559       else
1560         VecType = SemaRef.Context.getVectorType(elementType, numIElts,
1561                                                 IVT->getVectorKind());
1562       CheckSubElementType(ElementEntity, IList, VecType, Index,
1563                           StructuredList, StructuredIndex);
1564       numEltsInit += numIElts;
1565     }
1566   }
1567
1568   // OpenCL requires all elements to be initialized.
1569   if (numEltsInit != maxElements) {
1570     if (!VerifyOnly)
1571       SemaRef.Diag(IList->getLocStart(),
1572                    diag::err_vector_incorrect_num_initializers)
1573         << (numEltsInit < maxElements) << maxElements << numEltsInit;
1574     hadError = true;
1575   }
1576 }
1577
1578 void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
1579                                      InitListExpr *IList, QualType &DeclType,
1580                                      llvm::APSInt elementIndex,
1581                                      bool SubobjectIsDesignatorContext,
1582                                      unsigned &Index,
1583                                      InitListExpr *StructuredList,
1584                                      unsigned &StructuredIndex) {
1585   const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType);
1586
1587   // Check for the special-case of initializing an array with a string.
1588   if (Index < IList->getNumInits()) {
1589     if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) ==
1590         SIF_None) {
1591       // We place the string literal directly into the resulting
1592       // initializer list. This is the only place where the structure
1593       // of the structured initializer list doesn't match exactly,
1594       // because doing so would involve allocating one character
1595       // constant for each string.
1596       if (!VerifyOnly) {
1597         CheckStringInit(IList->getInit(Index), DeclType, arrayType, SemaRef);
1598         UpdateStructuredListElement(StructuredList, StructuredIndex,
1599                                     IList->getInit(Index));
1600         StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
1601       }
1602       ++Index;
1603       return;
1604     }
1605   }
1606   if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
1607     // Check for VLAs; in standard C it would be possible to check this
1608     // earlier, but I don't know where clang accepts VLAs (gcc accepts
1609     // them in all sorts of strange places).
1610     if (!VerifyOnly)
1611       SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
1612                     diag::err_variable_object_no_init)
1613         << VAT->getSizeExpr()->getSourceRange();
1614     hadError = true;
1615     ++Index;
1616     ++StructuredIndex;
1617     return;
1618   }
1619
1620   // We might know the maximum number of elements in advance.
1621   llvm::APSInt maxElements(elementIndex.getBitWidth(),
1622                            elementIndex.isUnsigned());
1623   bool maxElementsKnown = false;
1624   if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) {
1625     maxElements = CAT->getSize();
1626     elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
1627     elementIndex.setIsUnsigned(maxElements.isUnsigned());
1628     maxElementsKnown = true;
1629   }
1630
1631   QualType elementType = arrayType->getElementType();
1632   while (Index < IList->getNumInits()) {
1633     Expr *Init = IList->getInit(Index);
1634     if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1635       // If we're not the subobject that matches up with the '{' for
1636       // the designator, we shouldn't be handling the
1637       // designator. Return immediately.
1638       if (!SubobjectIsDesignatorContext)
1639         return;
1640
1641       // Handle this designated initializer. elementIndex will be
1642       // updated to be the next array element we'll initialize.
1643       if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1644                                      DeclType, nullptr, &elementIndex, Index,
1645                                      StructuredList, StructuredIndex, true,
1646                                      false)) {
1647         hadError = true;
1648         continue;
1649       }
1650
1651       if (elementIndex.getBitWidth() > maxElements.getBitWidth())
1652         maxElements = maxElements.extend(elementIndex.getBitWidth());
1653       else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
1654         elementIndex = elementIndex.extend(maxElements.getBitWidth());
1655       elementIndex.setIsUnsigned(maxElements.isUnsigned());
1656
1657       // If the array is of incomplete type, keep track of the number of
1658       // elements in the initializer.
1659       if (!maxElementsKnown && elementIndex > maxElements)
1660         maxElements = elementIndex;
1661
1662       continue;
1663     }
1664
1665     // If we know the maximum number of elements, and we've already
1666     // hit it, stop consuming elements in the initializer list.
1667     if (maxElementsKnown && elementIndex == maxElements)
1668       break;
1669
1670     InitializedEntity ElementEntity =
1671       InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
1672                                            Entity);
1673     // Check this element.
1674     CheckSubElementType(ElementEntity, IList, elementType, Index,
1675                         StructuredList, StructuredIndex);
1676     ++elementIndex;
1677
1678     // If the array is of incomplete type, keep track of the number of
1679     // elements in the initializer.
1680     if (!maxElementsKnown && elementIndex > maxElements)
1681       maxElements = elementIndex;
1682   }
1683   if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) {
1684     // If this is an incomplete array type, the actual type needs to
1685     // be calculated here.
1686     llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
1687     if (maxElements == Zero && !Entity.isVariableLengthArrayNew()) {
1688       // Sizing an array implicitly to zero is not allowed by ISO C,
1689       // but is supported by GNU.
1690       SemaRef.Diag(IList->getLocStart(),
1691                     diag::ext_typecheck_zero_array_size);
1692     }
1693
1694     DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
1695                                                      ArrayType::Normal, 0);
1696   }
1697   if (!hadError && VerifyOnly) {
1698     // If there are any members of the array that get value-initialized, check
1699     // that is possible. That happens if we know the bound and don't have
1700     // enough elements, or if we're performing an array new with an unknown
1701     // bound.
1702     // FIXME: This needs to detect holes left by designated initializers too.
1703     if ((maxElementsKnown && elementIndex < maxElements) ||
1704         Entity.isVariableLengthArrayNew())
1705       CheckEmptyInitializable(InitializedEntity::InitializeElement(
1706                                                   SemaRef.Context, 0, Entity),
1707                               IList->getLocEnd());
1708   }
1709 }
1710
1711 bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity,
1712                                              Expr *InitExpr,
1713                                              FieldDecl *Field,
1714                                              bool TopLevelObject) {
1715   // Handle GNU flexible array initializers.
1716   unsigned FlexArrayDiag;
1717   if (isa<InitListExpr>(InitExpr) &&
1718       cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
1719     // Empty flexible array init always allowed as an extension
1720     FlexArrayDiag = diag::ext_flexible_array_init;
1721   } else if (SemaRef.getLangOpts().CPlusPlus) {
1722     // Disallow flexible array init in C++; it is not required for gcc
1723     // compatibility, and it needs work to IRGen correctly in general.
1724     FlexArrayDiag = diag::err_flexible_array_init;
1725   } else if (!TopLevelObject) {
1726     // Disallow flexible array init on non-top-level object
1727     FlexArrayDiag = diag::err_flexible_array_init;
1728   } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
1729     // Disallow flexible array init on anything which is not a variable.
1730     FlexArrayDiag = diag::err_flexible_array_init;
1731   } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) {
1732     // Disallow flexible array init on local variables.
1733     FlexArrayDiag = diag::err_flexible_array_init;
1734   } else {
1735     // Allow other cases.
1736     FlexArrayDiag = diag::ext_flexible_array_init;
1737   }
1738
1739   if (!VerifyOnly) {
1740     SemaRef.Diag(InitExpr->getLocStart(),
1741                  FlexArrayDiag)
1742       << InitExpr->getLocStart();
1743     SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1744       << Field;
1745   }
1746
1747   return FlexArrayDiag != diag::ext_flexible_array_init;
1748 }
1749
1750 void InitListChecker::CheckStructUnionTypes(
1751     const InitializedEntity &Entity, InitListExpr *IList, QualType DeclType,
1752     CXXRecordDecl::base_class_range Bases, RecordDecl::field_iterator Field,
1753     bool SubobjectIsDesignatorContext, unsigned &Index,
1754     InitListExpr *StructuredList, unsigned &StructuredIndex,
1755     bool TopLevelObject) {
1756   RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
1757
1758   // If the record is invalid, some of it's members are invalid. To avoid
1759   // confusion, we forgo checking the intializer for the entire record.
1760   if (structDecl->isInvalidDecl()) {
1761     // Assume it was supposed to consume a single initializer.
1762     ++Index;
1763     hadError = true;
1764     return;
1765   }
1766
1767   if (DeclType->isUnionType() && IList->getNumInits() == 0) {
1768     RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1769
1770     // If there's a default initializer, use it.
1771     if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
1772       if (VerifyOnly)
1773         return;
1774       for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1775            Field != FieldEnd; ++Field) {
1776         if (Field->hasInClassInitializer()) {
1777           StructuredList->setInitializedFieldInUnion(*Field);
1778           // FIXME: Actually build a CXXDefaultInitExpr?
1779           return;
1780         }
1781       }
1782     }
1783
1784     // Value-initialize the first member of the union that isn't an unnamed
1785     // bitfield.
1786     for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1787          Field != FieldEnd; ++Field) {
1788       if (!Field->isUnnamedBitfield()) {
1789         if (VerifyOnly)
1790           CheckEmptyInitializable(
1791               InitializedEntity::InitializeMember(*Field, &Entity),
1792               IList->getLocEnd());
1793         else
1794           StructuredList->setInitializedFieldInUnion(*Field);
1795         break;
1796       }
1797     }
1798     return;
1799   }
1800
1801   bool InitializedSomething = false;
1802
1803   // If we have any base classes, they are initialized prior to the fields.
1804   for (auto &Base : Bases) {
1805     Expr *Init = Index < IList->getNumInits() ? IList->getInit(Index) : nullptr;
1806     SourceLocation InitLoc = Init ? Init->getLocStart() : IList->getLocEnd();
1807
1808     // Designated inits always initialize fields, so if we see one, all
1809     // remaining base classes have no explicit initializer.
1810     if (Init && isa<DesignatedInitExpr>(Init))
1811       Init = nullptr;
1812
1813     InitializedEntity BaseEntity = InitializedEntity::InitializeBase(
1814         SemaRef.Context, &Base, false, &Entity);
1815     if (Init) {
1816       CheckSubElementType(BaseEntity, IList, Base.getType(), Index,
1817                           StructuredList, StructuredIndex);
1818       InitializedSomething = true;
1819     } else if (VerifyOnly) {
1820       CheckEmptyInitializable(BaseEntity, InitLoc);
1821     }
1822   }
1823
1824   // If structDecl is a forward declaration, this loop won't do
1825   // anything except look at designated initializers; That's okay,
1826   // because an error should get printed out elsewhere. It might be
1827   // worthwhile to skip over the rest of the initializer, though.
1828   RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1829   RecordDecl::field_iterator FieldEnd = RD->field_end();
1830   bool CheckForMissingFields = true;
1831   while (Index < IList->getNumInits()) {
1832     Expr *Init = IList->getInit(Index);
1833
1834     if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1835       // If we're not the subobject that matches up with the '{' for
1836       // the designator, we shouldn't be handling the
1837       // designator. Return immediately.
1838       if (!SubobjectIsDesignatorContext)
1839         return;
1840
1841       // Handle this designated initializer. Field will be updated to
1842       // the next field that we'll be initializing.
1843       if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1844                                      DeclType, &Field, nullptr, Index,
1845                                      StructuredList, StructuredIndex,
1846                                      true, TopLevelObject))
1847         hadError = true;
1848
1849       InitializedSomething = true;
1850
1851       // Disable check for missing fields when designators are used.
1852       // This matches gcc behaviour.
1853       CheckForMissingFields = false;
1854       continue;
1855     }
1856
1857     if (Field == FieldEnd) {
1858       // We've run out of fields. We're done.
1859       break;
1860     }
1861
1862     // We've already initialized a member of a union. We're done.
1863     if (InitializedSomething && DeclType->isUnionType())
1864       break;
1865
1866     // If we've hit the flexible array member at the end, we're done.
1867     if (Field->getType()->isIncompleteArrayType())
1868       break;
1869
1870     if (Field->isUnnamedBitfield()) {
1871       // Don't initialize unnamed bitfields, e.g. "int : 20;"
1872       ++Field;
1873       continue;
1874     }
1875
1876     // Make sure we can use this declaration.
1877     bool InvalidUse;
1878     if (VerifyOnly)
1879       InvalidUse = !SemaRef.CanUseDecl(*Field, TreatUnavailableAsInvalid);
1880     else
1881       InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field,
1882                                           IList->getInit(Index)->getLocStart());
1883     if (InvalidUse) {
1884       ++Index;
1885       ++Field;
1886       hadError = true;
1887       continue;
1888     }
1889
1890     InitializedEntity MemberEntity =
1891       InitializedEntity::InitializeMember(*Field, &Entity);
1892     CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1893                         StructuredList, StructuredIndex);
1894     InitializedSomething = true;
1895
1896     if (DeclType->isUnionType() && !VerifyOnly) {
1897       // Initialize the first field within the union.
1898       StructuredList->setInitializedFieldInUnion(*Field);
1899     }
1900
1901     ++Field;
1902   }
1903
1904   // Emit warnings for missing struct field initializers.
1905   if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
1906       Field != FieldEnd && !Field->getType()->isIncompleteArrayType() &&
1907       !DeclType->isUnionType()) {
1908     // It is possible we have one or more unnamed bitfields remaining.
1909     // Find first (if any) named field and emit warning.
1910     for (RecordDecl::field_iterator it = Field, end = RD->field_end();
1911          it != end; ++it) {
1912       if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) {
1913         SemaRef.Diag(IList->getSourceRange().getEnd(),
1914                      diag::warn_missing_field_initializers) << *it;
1915         break;
1916       }
1917     }
1918   }
1919
1920   // Check that any remaining fields can be value-initialized.
1921   if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() &&
1922       !Field->getType()->isIncompleteArrayType()) {
1923     // FIXME: Should check for holes left by designated initializers too.
1924     for (; Field != FieldEnd && !hadError; ++Field) {
1925       if (!Field->isUnnamedBitfield() && !Field->hasInClassInitializer())
1926         CheckEmptyInitializable(
1927             InitializedEntity::InitializeMember(*Field, &Entity),
1928             IList->getLocEnd());
1929     }
1930   }
1931
1932   if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
1933       Index >= IList->getNumInits())
1934     return;
1935
1936   if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field,
1937                              TopLevelObject)) {
1938     hadError = true;
1939     ++Index;
1940     return;
1941   }
1942
1943   InitializedEntity MemberEntity =
1944     InitializedEntity::InitializeMember(*Field, &Entity);
1945
1946   if (isa<InitListExpr>(IList->getInit(Index)))
1947     CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1948                         StructuredList, StructuredIndex);
1949   else
1950     CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
1951                           StructuredList, StructuredIndex);
1952 }
1953
1954 /// \brief Expand a field designator that refers to a member of an
1955 /// anonymous struct or union into a series of field designators that
1956 /// refers to the field within the appropriate subobject.
1957 ///
1958 static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
1959                                            DesignatedInitExpr *DIE,
1960                                            unsigned DesigIdx,
1961                                            IndirectFieldDecl *IndirectField) {
1962   typedef DesignatedInitExpr::Designator Designator;
1963
1964   // Build the replacement designators.
1965   SmallVector<Designator, 4> Replacements;
1966   for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
1967        PE = IndirectField->chain_end(); PI != PE; ++PI) {
1968     if (PI + 1 == PE)
1969       Replacements.push_back(Designator((IdentifierInfo *)nullptr,
1970                                     DIE->getDesignator(DesigIdx)->getDotLoc(),
1971                                 DIE->getDesignator(DesigIdx)->getFieldLoc()));
1972     else
1973       Replacements.push_back(Designator((IdentifierInfo *)nullptr,
1974                                         SourceLocation(), SourceLocation()));
1975     assert(isa<FieldDecl>(*PI));
1976     Replacements.back().setField(cast<FieldDecl>(*PI));
1977   }
1978
1979   // Expand the current designator into the set of replacement
1980   // designators, so we have a full subobject path down to where the
1981   // member of the anonymous struct/union is actually stored.
1982   DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
1983                         &Replacements[0] + Replacements.size());
1984 }
1985
1986 static DesignatedInitExpr *CloneDesignatedInitExpr(Sema &SemaRef,
1987                                                    DesignatedInitExpr *DIE) {
1988   unsigned NumIndexExprs = DIE->getNumSubExprs() - 1;
1989   SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
1990   for (unsigned I = 0; I < NumIndexExprs; ++I)
1991     IndexExprs[I] = DIE->getSubExpr(I + 1);
1992   return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators(),
1993                                     IndexExprs,
1994                                     DIE->getEqualOrColonLoc(),
1995                                     DIE->usesGNUSyntax(), DIE->getInit());
1996 }
1997
1998 namespace {
1999
2000 // Callback to only accept typo corrections that are for field members of
2001 // the given struct or union.
2002 class FieldInitializerValidatorCCC : public CorrectionCandidateCallback {
2003  public:
2004   explicit FieldInitializerValidatorCCC(RecordDecl *RD)
2005       : Record(RD) {}
2006
2007   bool ValidateCandidate(const TypoCorrection &candidate) override {
2008     FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>();
2009     return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record);
2010   }
2011
2012  private:
2013   RecordDecl *Record;
2014 };
2015
2016 } // end anonymous namespace
2017
2018 /// @brief Check the well-formedness of a C99 designated initializer.
2019 ///
2020 /// Determines whether the designated initializer @p DIE, which
2021 /// resides at the given @p Index within the initializer list @p
2022 /// IList, is well-formed for a current object of type @p DeclType
2023 /// (C99 6.7.8). The actual subobject that this designator refers to
2024 /// within the current subobject is returned in either
2025 /// @p NextField or @p NextElementIndex (whichever is appropriate).
2026 ///
2027 /// @param IList  The initializer list in which this designated
2028 /// initializer occurs.
2029 ///
2030 /// @param DIE The designated initializer expression.
2031 ///
2032 /// @param DesigIdx  The index of the current designator.
2033 ///
2034 /// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
2035 /// into which the designation in @p DIE should refer.
2036 ///
2037 /// @param NextField  If non-NULL and the first designator in @p DIE is
2038 /// a field, this will be set to the field declaration corresponding
2039 /// to the field named by the designator.
2040 ///
2041 /// @param NextElementIndex  If non-NULL and the first designator in @p
2042 /// DIE is an array designator or GNU array-range designator, this
2043 /// will be set to the last index initialized by this designator.
2044 ///
2045 /// @param Index  Index into @p IList where the designated initializer
2046 /// @p DIE occurs.
2047 ///
2048 /// @param StructuredList  The initializer list expression that
2049 /// describes all of the subobject initializers in the order they'll
2050 /// actually be initialized.
2051 ///
2052 /// @returns true if there was an error, false otherwise.
2053 bool
2054 InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
2055                                             InitListExpr *IList,
2056                                             DesignatedInitExpr *DIE,
2057                                             unsigned DesigIdx,
2058                                             QualType &CurrentObjectType,
2059                                           RecordDecl::field_iterator *NextField,
2060                                             llvm::APSInt *NextElementIndex,
2061                                             unsigned &Index,
2062                                             InitListExpr *StructuredList,
2063                                             unsigned &StructuredIndex,
2064                                             bool FinishSubobjectInit,
2065                                             bool TopLevelObject) {
2066   if (DesigIdx == DIE->size()) {
2067     // Check the actual initialization for the designated object type.
2068     bool prevHadError = hadError;
2069
2070     // Temporarily remove the designator expression from the
2071     // initializer list that the child calls see, so that we don't try
2072     // to re-process the designator.
2073     unsigned OldIndex = Index;
2074     IList->setInit(OldIndex, DIE->getInit());
2075
2076     CheckSubElementType(Entity, IList, CurrentObjectType, Index,
2077                         StructuredList, StructuredIndex);
2078
2079     // Restore the designated initializer expression in the syntactic
2080     // form of the initializer list.
2081     if (IList->getInit(OldIndex) != DIE->getInit())
2082       DIE->setInit(IList->getInit(OldIndex));
2083     IList->setInit(OldIndex, DIE);
2084
2085     return hadError && !prevHadError;
2086   }
2087
2088   DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
2089   bool IsFirstDesignator = (DesigIdx == 0);
2090   if (!VerifyOnly) {
2091     assert((IsFirstDesignator || StructuredList) &&
2092            "Need a non-designated initializer list to start from");
2093
2094     // Determine the structural initializer list that corresponds to the
2095     // current subobject.
2096     if (IsFirstDesignator)
2097       StructuredList = SyntacticToSemantic.lookup(IList);
2098     else {
2099       Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2100           StructuredList->getInit(StructuredIndex) : nullptr;
2101       if (!ExistingInit && StructuredList->hasArrayFiller())
2102         ExistingInit = StructuredList->getArrayFiller();
2103
2104       if (!ExistingInit)
2105         StructuredList =
2106           getStructuredSubobjectInit(IList, Index, CurrentObjectType,
2107                                      StructuredList, StructuredIndex,
2108                                      SourceRange(D->getLocStart(),
2109                                                  DIE->getLocEnd()));
2110       else if (InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2111         StructuredList = Result;
2112       else {
2113         if (DesignatedInitUpdateExpr *E =
2114                 dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2115           StructuredList = E->getUpdater();
2116         else {
2117           DesignatedInitUpdateExpr *DIUE =
2118               new (SemaRef.Context) DesignatedInitUpdateExpr(SemaRef.Context,
2119                                         D->getLocStart(), ExistingInit,
2120                                         DIE->getLocEnd());
2121           StructuredList->updateInit(SemaRef.Context, StructuredIndex, DIUE);
2122           StructuredList = DIUE->getUpdater();
2123         }
2124
2125         // We need to check on source range validity because the previous
2126         // initializer does not have to be an explicit initializer. e.g.,
2127         //
2128         // struct P { int a, b; };
2129         // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2130         //
2131         // There is an overwrite taking place because the first braced initializer
2132         // list "{ .a = 2 }" already provides value for .p.b (which is zero).
2133         if (ExistingInit->getSourceRange().isValid()) {
2134           // We are creating an initializer list that initializes the
2135           // subobjects of the current object, but there was already an
2136           // initialization that completely initialized the current
2137           // subobject, e.g., by a compound literal:
2138           //
2139           // struct X { int a, b; };
2140           // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2141           //
2142           // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2143           // designated initializer re-initializes the whole
2144           // subobject [0], overwriting previous initializers.
2145           SemaRef.Diag(D->getLocStart(),
2146                        diag::warn_subobject_initializer_overrides)
2147             << SourceRange(D->getLocStart(), DIE->getLocEnd());
2148
2149           SemaRef.Diag(ExistingInit->getLocStart(),
2150                        diag::note_previous_initializer)
2151             << /*FIXME:has side effects=*/0
2152             << ExistingInit->getSourceRange();
2153         }
2154       }
2155     }
2156     assert(StructuredList && "Expected a structured initializer list");
2157   }
2158
2159   if (D->isFieldDesignator()) {
2160     // C99 6.7.8p7:
2161     //
2162     //   If a designator has the form
2163     //
2164     //      . identifier
2165     //
2166     //   then the current object (defined below) shall have
2167     //   structure or union type and the identifier shall be the
2168     //   name of a member of that type.
2169     const RecordType *RT = CurrentObjectType->getAs<RecordType>();
2170     if (!RT) {
2171       SourceLocation Loc = D->getDotLoc();
2172       if (Loc.isInvalid())
2173         Loc = D->getFieldLoc();
2174       if (!VerifyOnly)
2175         SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
2176           << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
2177       ++Index;
2178       return true;
2179     }
2180
2181     FieldDecl *KnownField = D->getField();
2182     if (!KnownField) {
2183       IdentifierInfo *FieldName = D->getFieldName();
2184       DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
2185       for (NamedDecl *ND : Lookup) {
2186         if (auto *FD = dyn_cast<FieldDecl>(ND)) {
2187           KnownField = FD;
2188           break;
2189         }
2190         if (auto *IFD = dyn_cast<IndirectFieldDecl>(ND)) {
2191           // In verify mode, don't modify the original.
2192           if (VerifyOnly)
2193             DIE = CloneDesignatedInitExpr(SemaRef, DIE);
2194           ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IFD);
2195           D = DIE->getDesignator(DesigIdx);
2196           KnownField = cast<FieldDecl>(*IFD->chain_begin());
2197           break;
2198         }
2199       }
2200       if (!KnownField) {
2201         if (VerifyOnly) {
2202           ++Index;
2203           return true;  // No typo correction when just trying this out.
2204         }
2205
2206         // Name lookup found something, but it wasn't a field.
2207         if (!Lookup.empty()) {
2208           SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
2209             << FieldName;
2210           SemaRef.Diag(Lookup.front()->getLocation(),
2211                        diag::note_field_designator_found);
2212           ++Index;
2213           return true;
2214         }
2215
2216         // Name lookup didn't find anything.
2217         // Determine whether this was a typo for another field name.
2218         if (TypoCorrection Corrected = SemaRef.CorrectTypo(
2219                 DeclarationNameInfo(FieldName, D->getFieldLoc()),
2220                 Sema::LookupMemberName, /*Scope=*/nullptr, /*SS=*/nullptr,
2221                 llvm::make_unique<FieldInitializerValidatorCCC>(RT->getDecl()),
2222                 Sema::CTK_ErrorRecovery, RT->getDecl())) {
2223           SemaRef.diagnoseTypo(
2224               Corrected,
2225               SemaRef.PDiag(diag::err_field_designator_unknown_suggest)
2226                 << FieldName << CurrentObjectType);
2227           KnownField = Corrected.getCorrectionDeclAs<FieldDecl>();
2228           hadError = true;
2229         } else {
2230           // Typo correction didn't find anything.
2231           SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
2232             << FieldName << CurrentObjectType;
2233           ++Index;
2234           return true;
2235         }
2236       }
2237     }
2238
2239     unsigned FieldIndex = 0;
2240     for (auto *FI : RT->getDecl()->fields()) {
2241       if (FI->isUnnamedBitfield())
2242         continue;
2243       if (declaresSameEntity(KnownField, FI)) {
2244         KnownField = FI;
2245         break;
2246       }
2247       ++FieldIndex;
2248     }
2249
2250     RecordDecl::field_iterator Field =
2251         RecordDecl::field_iterator(DeclContext::decl_iterator(KnownField));
2252
2253     // All of the fields of a union are located at the same place in
2254     // the initializer list.
2255     if (RT->getDecl()->isUnion()) {
2256       FieldIndex = 0;
2257       if (!VerifyOnly) {
2258         FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2259         if (CurrentField && !declaresSameEntity(CurrentField, *Field)) {
2260           assert(StructuredList->getNumInits() == 1
2261                  && "A union should never have more than one initializer!");
2262
2263           // We're about to throw away an initializer, emit warning.
2264           SemaRef.Diag(D->getFieldLoc(),
2265                        diag::warn_initializer_overrides)
2266             << D->getSourceRange();
2267           Expr *ExistingInit = StructuredList->getInit(0);
2268           SemaRef.Diag(ExistingInit->getLocStart(),
2269                        diag::note_previous_initializer)
2270             << /*FIXME:has side effects=*/0
2271             << ExistingInit->getSourceRange();
2272
2273           // remove existing initializer
2274           StructuredList->resizeInits(SemaRef.Context, 0);
2275           StructuredList->setInitializedFieldInUnion(nullptr);
2276         }
2277
2278         StructuredList->setInitializedFieldInUnion(*Field);
2279       }
2280     }
2281
2282     // Make sure we can use this declaration.
2283     bool InvalidUse;
2284     if (VerifyOnly)
2285       InvalidUse = !SemaRef.CanUseDecl(*Field, TreatUnavailableAsInvalid);
2286     else
2287       InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
2288     if (InvalidUse) {
2289       ++Index;
2290       return true;
2291     }
2292
2293     if (!VerifyOnly) {
2294       // Update the designator with the field declaration.
2295       D->setField(*Field);
2296
2297       // Make sure that our non-designated initializer list has space
2298       // for a subobject corresponding to this field.
2299       if (FieldIndex >= StructuredList->getNumInits())
2300         StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
2301     }
2302
2303     // This designator names a flexible array member.
2304     if (Field->getType()->isIncompleteArrayType()) {
2305       bool Invalid = false;
2306       if ((DesigIdx + 1) != DIE->size()) {
2307         // We can't designate an object within the flexible array
2308         // member (because GCC doesn't allow it).
2309         if (!VerifyOnly) {
2310           DesignatedInitExpr::Designator *NextD
2311             = DIE->getDesignator(DesigIdx + 1);
2312           SemaRef.Diag(NextD->getLocStart(),
2313                         diag::err_designator_into_flexible_array_member)
2314             << SourceRange(NextD->getLocStart(),
2315                            DIE->getLocEnd());
2316           SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2317             << *Field;
2318         }
2319         Invalid = true;
2320       }
2321
2322       if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
2323           !isa<StringLiteral>(DIE->getInit())) {
2324         // The initializer is not an initializer list.
2325         if (!VerifyOnly) {
2326           SemaRef.Diag(DIE->getInit()->getLocStart(),
2327                         diag::err_flexible_array_init_needs_braces)
2328             << DIE->getInit()->getSourceRange();
2329           SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2330             << *Field;
2331         }
2332         Invalid = true;
2333       }
2334
2335       // Check GNU flexible array initializer.
2336       if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
2337                                              TopLevelObject))
2338         Invalid = true;
2339
2340       if (Invalid) {
2341         ++Index;
2342         return true;
2343       }
2344
2345       // Initialize the array.
2346       bool prevHadError = hadError;
2347       unsigned newStructuredIndex = FieldIndex;
2348       unsigned OldIndex = Index;
2349       IList->setInit(Index, DIE->getInit());
2350
2351       InitializedEntity MemberEntity =
2352         InitializedEntity::InitializeMember(*Field, &Entity);
2353       CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
2354                           StructuredList, newStructuredIndex);
2355
2356       IList->setInit(OldIndex, DIE);
2357       if (hadError && !prevHadError) {
2358         ++Field;
2359         ++FieldIndex;
2360         if (NextField)
2361           *NextField = Field;
2362         StructuredIndex = FieldIndex;
2363         return true;
2364       }
2365     } else {
2366       // Recurse to check later designated subobjects.
2367       QualType FieldType = Field->getType();
2368       unsigned newStructuredIndex = FieldIndex;
2369
2370       InitializedEntity MemberEntity =
2371         InitializedEntity::InitializeMember(*Field, &Entity);
2372       if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2373                                      FieldType, nullptr, nullptr, Index,
2374                                      StructuredList, newStructuredIndex,
2375                                      FinishSubobjectInit, false))
2376         return true;
2377     }
2378
2379     // Find the position of the next field to be initialized in this
2380     // subobject.
2381     ++Field;
2382     ++FieldIndex;
2383
2384     // If this the first designator, our caller will continue checking
2385     // the rest of this struct/class/union subobject.
2386     if (IsFirstDesignator) {
2387       if (NextField)
2388         *NextField = Field;
2389       StructuredIndex = FieldIndex;
2390       return false;
2391     }
2392
2393     if (!FinishSubobjectInit)
2394       return false;
2395
2396     // We've already initialized something in the union; we're done.
2397     if (RT->getDecl()->isUnion())
2398       return hadError;
2399
2400     // Check the remaining fields within this class/struct/union subobject.
2401     bool prevHadError = hadError;
2402
2403     auto NoBases =
2404         CXXRecordDecl::base_class_range(CXXRecordDecl::base_class_iterator(),
2405                                         CXXRecordDecl::base_class_iterator());
2406     CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,
2407                           false, Index, StructuredList, FieldIndex);
2408     return hadError && !prevHadError;
2409   }
2410
2411   // C99 6.7.8p6:
2412   //
2413   //   If a designator has the form
2414   //
2415   //      [ constant-expression ]
2416   //
2417   //   then the current object (defined below) shall have array
2418   //   type and the expression shall be an integer constant
2419   //   expression. If the array is of unknown size, any
2420   //   nonnegative value is valid.
2421   //
2422   // Additionally, cope with the GNU extension that permits
2423   // designators of the form
2424   //
2425   //      [ constant-expression ... constant-expression ]
2426   const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
2427   if (!AT) {
2428     if (!VerifyOnly)
2429       SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
2430         << CurrentObjectType;
2431     ++Index;
2432     return true;
2433   }
2434
2435   Expr *IndexExpr = nullptr;
2436   llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2437   if (D->isArrayDesignator()) {
2438     IndexExpr = DIE->getArrayIndex(*D);
2439     DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
2440     DesignatedEndIndex = DesignatedStartIndex;
2441   } else {
2442     assert(D->isArrayRangeDesignator() && "Need array-range designator");
2443
2444     DesignatedStartIndex =
2445       DIE->getArrayRangeStart(*D)->EvaluateKnownConstInt(SemaRef.Context);
2446     DesignatedEndIndex =
2447       DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
2448     IndexExpr = DIE->getArrayRangeEnd(*D);
2449
2450     // Codegen can't handle evaluating array range designators that have side
2451     // effects, because we replicate the AST value for each initialized element.
2452     // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
2453     // elements with something that has a side effect, so codegen can emit an
2454     // "error unsupported" error instead of miscompiling the app.
2455     if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
2456         DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
2457       FullyStructuredList->sawArrayRangeDesignator();
2458   }
2459
2460   if (isa<ConstantArrayType>(AT)) {
2461     llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
2462     DesignatedStartIndex
2463       = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
2464     DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
2465     DesignatedEndIndex
2466       = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
2467     DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2468     if (DesignatedEndIndex >= MaxElements) {
2469       if (!VerifyOnly)
2470         SemaRef.Diag(IndexExpr->getLocStart(),
2471                       diag::err_array_designator_too_large)
2472           << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
2473           << IndexExpr->getSourceRange();
2474       ++Index;
2475       return true;
2476     }
2477   } else {
2478     unsigned DesignatedIndexBitWidth =
2479       ConstantArrayType::getMaxSizeBits(SemaRef.Context);
2480     DesignatedStartIndex =
2481       DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
2482     DesignatedEndIndex =
2483       DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
2484     DesignatedStartIndex.setIsUnsigned(true);
2485     DesignatedEndIndex.setIsUnsigned(true);
2486   }
2487
2488   if (!VerifyOnly && StructuredList->isStringLiteralInit()) {
2489     // We're modifying a string literal init; we have to decompose the string
2490     // so we can modify the individual characters.
2491     ASTContext &Context = SemaRef.Context;
2492     Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2493
2494     // Compute the character type
2495     QualType CharTy = AT->getElementType();
2496
2497     // Compute the type of the integer literals.
2498     QualType PromotedCharTy = CharTy;
2499     if (CharTy->isPromotableIntegerType())
2500       PromotedCharTy = Context.getPromotedIntegerType(CharTy);
2501     unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
2502
2503     if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
2504       // Get the length of the string.
2505       uint64_t StrLen = SL->getLength();
2506       if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2507         StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2508       StructuredList->resizeInits(Context, StrLen);
2509
2510       // Build a literal for each character in the string, and put them into
2511       // the init list.
2512       for (unsigned i = 0, e = StrLen; i != e; ++i) {
2513         llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2514         Expr *Init = new (Context) IntegerLiteral(
2515             Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2516         if (CharTy != PromotedCharTy)
2517           Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2518                                           Init, nullptr, VK_RValue);
2519         StructuredList->updateInit(Context, i, Init);
2520       }
2521     } else {
2522       ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
2523       std::string Str;
2524       Context.getObjCEncodingForType(E->getEncodedType(), Str);
2525
2526       // Get the length of the string.
2527       uint64_t StrLen = Str.size();
2528       if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2529         StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2530       StructuredList->resizeInits(Context, StrLen);
2531
2532       // Build a literal for each character in the string, and put them into
2533       // the init list.
2534       for (unsigned i = 0, e = StrLen; i != e; ++i) {
2535         llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2536         Expr *Init = new (Context) IntegerLiteral(
2537             Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2538         if (CharTy != PromotedCharTy)
2539           Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2540                                           Init, nullptr, VK_RValue);
2541         StructuredList->updateInit(Context, i, Init);
2542       }
2543     }
2544   }
2545
2546   // Make sure that our non-designated initializer list has space
2547   // for a subobject corresponding to this array element.
2548   if (!VerifyOnly &&
2549       DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
2550     StructuredList->resizeInits(SemaRef.Context,
2551                                 DesignatedEndIndex.getZExtValue() + 1);
2552
2553   // Repeatedly perform subobject initializations in the range
2554   // [DesignatedStartIndex, DesignatedEndIndex].
2555
2556   // Move to the next designator
2557   unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
2558   unsigned OldIndex = Index;
2559
2560   InitializedEntity ElementEntity =
2561     InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
2562
2563   while (DesignatedStartIndex <= DesignatedEndIndex) {
2564     // Recurse to check later designated subobjects.
2565     QualType ElementType = AT->getElementType();
2566     Index = OldIndex;
2567
2568     ElementEntity.setElementIndex(ElementIndex);
2569     if (CheckDesignatedInitializer(
2570             ElementEntity, IList, DIE, DesigIdx + 1, ElementType, nullptr,
2571             nullptr, Index, StructuredList, ElementIndex,
2572             FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),
2573             false))
2574       return true;
2575
2576     // Move to the next index in the array that we'll be initializing.
2577     ++DesignatedStartIndex;
2578     ElementIndex = DesignatedStartIndex.getZExtValue();
2579   }
2580
2581   // If this the first designator, our caller will continue checking
2582   // the rest of this array subobject.
2583   if (IsFirstDesignator) {
2584     if (NextElementIndex)
2585       *NextElementIndex = DesignatedStartIndex;
2586     StructuredIndex = ElementIndex;
2587     return false;
2588   }
2589
2590   if (!FinishSubobjectInit)
2591     return false;
2592
2593   // Check the remaining elements within this array subobject.
2594   bool prevHadError = hadError;
2595   CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
2596                  /*SubobjectIsDesignatorContext=*/false, Index,
2597                  StructuredList, ElementIndex);
2598   return hadError && !prevHadError;
2599 }
2600
2601 // Get the structured initializer list for a subobject of type
2602 // @p CurrentObjectType.
2603 InitListExpr *
2604 InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2605                                             QualType CurrentObjectType,
2606                                             InitListExpr *StructuredList,
2607                                             unsigned StructuredIndex,
2608                                             SourceRange InitRange,
2609                                             bool IsFullyOverwritten) {
2610   if (VerifyOnly)
2611     return nullptr; // No structured list in verification-only mode.
2612   Expr *ExistingInit = nullptr;
2613   if (!StructuredList)
2614     ExistingInit = SyntacticToSemantic.lookup(IList);
2615   else if (StructuredIndex < StructuredList->getNumInits())
2616     ExistingInit = StructuredList->getInit(StructuredIndex);
2617
2618   if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2619     // There might have already been initializers for subobjects of the current
2620     // object, but a subsequent initializer list will overwrite the entirety
2621     // of the current object. (See DR 253 and C99 6.7.8p21). e.g.,
2622     //
2623     // struct P { char x[6]; };
2624     // struct P l = { .x[2] = 'x', .x = { [0] = 'f' } };
2625     //
2626     // The first designated initializer is ignored, and l.x is just "f".
2627     if (!IsFullyOverwritten)
2628       return Result;
2629
2630   if (ExistingInit) {
2631     // We are creating an initializer list that initializes the
2632     // subobjects of the current object, but there was already an
2633     // initialization that completely initialized the current
2634     // subobject, e.g., by a compound literal:
2635     //
2636     // struct X { int a, b; };
2637     // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2638     //
2639     // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2640     // designated initializer re-initializes the whole
2641     // subobject [0], overwriting previous initializers.
2642     SemaRef.Diag(InitRange.getBegin(),
2643                  diag::warn_subobject_initializer_overrides)
2644       << InitRange;
2645     SemaRef.Diag(ExistingInit->getLocStart(),
2646                   diag::note_previous_initializer)
2647       << /*FIXME:has side effects=*/0
2648       << ExistingInit->getSourceRange();
2649   }
2650
2651   InitListExpr *Result
2652     = new (SemaRef.Context) InitListExpr(SemaRef.Context,
2653                                          InitRange.getBegin(), None,
2654                                          InitRange.getEnd());
2655
2656   QualType ResultType = CurrentObjectType;
2657   if (!ResultType->isArrayType())
2658     ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2659   Result->setType(ResultType);
2660
2661   // Pre-allocate storage for the structured initializer list.
2662   unsigned NumElements = 0;
2663   unsigned NumInits = 0;
2664   bool GotNumInits = false;
2665   if (!StructuredList) {
2666     NumInits = IList->getNumInits();
2667     GotNumInits = true;
2668   } else if (Index < IList->getNumInits()) {
2669     if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
2670       NumInits = SubList->getNumInits();
2671       GotNumInits = true;
2672     }
2673   }
2674
2675   if (const ArrayType *AType
2676       = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2677     if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2678       NumElements = CAType->getSize().getZExtValue();
2679       // Simple heuristic so that we don't allocate a very large
2680       // initializer with many empty entries at the end.
2681       if (GotNumInits && NumElements > NumInits)
2682         NumElements = 0;
2683     }
2684   } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
2685     NumElements = VType->getNumElements();
2686   else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
2687     RecordDecl *RDecl = RType->getDecl();
2688     if (RDecl->isUnion())
2689       NumElements = 1;
2690     else
2691       NumElements = std::distance(RDecl->field_begin(), RDecl->field_end());
2692   }
2693
2694   Result->reserveInits(SemaRef.Context, NumElements);
2695
2696   // Link this new initializer list into the structured initializer
2697   // lists.
2698   if (StructuredList)
2699     StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
2700   else {
2701     Result->setSyntacticForm(IList);
2702     SyntacticToSemantic[IList] = Result;
2703   }
2704
2705   return Result;
2706 }
2707
2708 /// Update the initializer at index @p StructuredIndex within the
2709 /// structured initializer list to the value @p expr.
2710 void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2711                                                   unsigned &StructuredIndex,
2712                                                   Expr *expr) {
2713   // No structured initializer list to update
2714   if (!StructuredList)
2715     return;
2716
2717   if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2718                                                   StructuredIndex, expr)) {
2719     // This initializer overwrites a previous initializer. Warn.
2720     // We need to check on source range validity because the previous
2721     // initializer does not have to be an explicit initializer.
2722     // struct P { int a, b; };
2723     // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2724     // There is an overwrite taking place because the first braced initializer
2725     // list "{ .a = 2 }' already provides value for .p.b (which is zero).
2726     if (PrevInit->getSourceRange().isValid()) {
2727       SemaRef.Diag(expr->getLocStart(),
2728                    diag::warn_initializer_overrides)
2729         << expr->getSourceRange();
2730
2731       SemaRef.Diag(PrevInit->getLocStart(),
2732                    diag::note_previous_initializer)
2733         << /*FIXME:has side effects=*/0
2734         << PrevInit->getSourceRange();
2735     }
2736   }
2737
2738   ++StructuredIndex;
2739 }
2740
2741 /// Check that the given Index expression is a valid array designator
2742 /// value. This is essentially just a wrapper around
2743 /// VerifyIntegerConstantExpression that also checks for negative values
2744 /// and produces a reasonable diagnostic if there is a
2745 /// failure. Returns the index expression, possibly with an implicit cast
2746 /// added, on success.  If everything went okay, Value will receive the
2747 /// value of the constant expression.
2748 static ExprResult
2749 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
2750   SourceLocation Loc = Index->getLocStart();
2751
2752   // Make sure this is an integer constant expression.
2753   ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value);
2754   if (Result.isInvalid())
2755     return Result;
2756
2757   if (Value.isSigned() && Value.isNegative())
2758     return S.Diag(Loc, diag::err_array_designator_negative)
2759       << Value.toString(10) << Index->getSourceRange();
2760
2761   Value.setIsUnsigned(true);
2762   return Result;
2763 }
2764
2765 ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
2766                                             SourceLocation Loc,
2767                                             bool GNUSyntax,
2768                                             ExprResult Init) {
2769   typedef DesignatedInitExpr::Designator ASTDesignator;
2770
2771   bool Invalid = false;
2772   SmallVector<ASTDesignator, 32> Designators;
2773   SmallVector<Expr *, 32> InitExpressions;
2774
2775   // Build designators and check array designator expressions.
2776   for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2777     const Designator &D = Desig.getDesignator(Idx);
2778     switch (D.getKind()) {
2779     case Designator::FieldDesignator:
2780       Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
2781                                           D.getFieldLoc()));
2782       break;
2783
2784     case Designator::ArrayDesignator: {
2785       Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2786       llvm::APSInt IndexValue;
2787       if (!Index->isTypeDependent() && !Index->isValueDependent())
2788         Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get();
2789       if (!Index)
2790         Invalid = true;
2791       else {
2792         Designators.push_back(ASTDesignator(InitExpressions.size(),
2793                                             D.getLBracketLoc(),
2794                                             D.getRBracketLoc()));
2795         InitExpressions.push_back(Index);
2796       }
2797       break;
2798     }
2799
2800     case Designator::ArrayRangeDesignator: {
2801       Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
2802       Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
2803       llvm::APSInt StartValue;
2804       llvm::APSInt EndValue;
2805       bool StartDependent = StartIndex->isTypeDependent() ||
2806                             StartIndex->isValueDependent();
2807       bool EndDependent = EndIndex->isTypeDependent() ||
2808                           EndIndex->isValueDependent();
2809       if (!StartDependent)
2810         StartIndex =
2811             CheckArrayDesignatorExpr(*this, StartIndex, StartValue).get();
2812       if (!EndDependent)
2813         EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).get();
2814
2815       if (!StartIndex || !EndIndex)
2816         Invalid = true;
2817       else {
2818         // Make sure we're comparing values with the same bit width.
2819         if (StartDependent || EndDependent) {
2820           // Nothing to compute.
2821         } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
2822           EndValue = EndValue.extend(StartValue.getBitWidth());
2823         else if (StartValue.getBitWidth() < EndValue.getBitWidth())
2824           StartValue = StartValue.extend(EndValue.getBitWidth());
2825
2826         if (!StartDependent && !EndDependent && EndValue < StartValue) {
2827           Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
2828             << StartValue.toString(10) << EndValue.toString(10)
2829             << StartIndex->getSourceRange() << EndIndex->getSourceRange();
2830           Invalid = true;
2831         } else {
2832           Designators.push_back(ASTDesignator(InitExpressions.size(),
2833                                               D.getLBracketLoc(),
2834                                               D.getEllipsisLoc(),
2835                                               D.getRBracketLoc()));
2836           InitExpressions.push_back(StartIndex);
2837           InitExpressions.push_back(EndIndex);
2838         }
2839       }
2840       break;
2841     }
2842     }
2843   }
2844
2845   if (Invalid || Init.isInvalid())
2846     return ExprError();
2847
2848   // Clear out the expressions within the designation.
2849   Desig.ClearExprs(*this);
2850
2851   DesignatedInitExpr *DIE
2852     = DesignatedInitExpr::Create(Context,
2853                                  Designators,
2854                                  InitExpressions, Loc, GNUSyntax,
2855                                  Init.getAs<Expr>());
2856
2857   if (!getLangOpts().C99)
2858     Diag(DIE->getLocStart(), diag::ext_designated_init)
2859       << DIE->getSourceRange();
2860
2861   return DIE;
2862 }
2863
2864 //===----------------------------------------------------------------------===//
2865 // Initialization entity
2866 //===----------------------------------------------------------------------===//
2867
2868 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
2869                                      const InitializedEntity &Parent)
2870   : Parent(&Parent), Index(Index)
2871 {
2872   if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
2873     Kind = EK_ArrayElement;
2874     Type = AT->getElementType();
2875   } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
2876     Kind = EK_VectorElement;
2877     Type = VT->getElementType();
2878   } else {
2879     const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
2880     assert(CT && "Unexpected type");
2881     Kind = EK_ComplexElement;
2882     Type = CT->getElementType();
2883   }
2884 }
2885
2886 InitializedEntity
2887 InitializedEntity::InitializeBase(ASTContext &Context,
2888                                   const CXXBaseSpecifier *Base,
2889                                   bool IsInheritedVirtualBase,
2890                                   const InitializedEntity *Parent) {
2891   InitializedEntity Result;
2892   Result.Kind = EK_Base;
2893   Result.Parent = Parent;
2894   Result.Base = reinterpret_cast<uintptr_t>(Base);
2895   if (IsInheritedVirtualBase)
2896     Result.Base |= 0x01;
2897
2898   Result.Type = Base->getType();
2899   return Result;
2900 }
2901
2902 DeclarationName InitializedEntity::getName() const {
2903   switch (getKind()) {
2904   case EK_Parameter:
2905   case EK_Parameter_CF_Audited: {
2906     ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2907     return (D ? D->getDeclName() : DeclarationName());
2908   }
2909
2910   case EK_Variable:
2911   case EK_Member:
2912   case EK_Binding:
2913     return Variable.VariableOrMember->getDeclName();
2914
2915   case EK_LambdaCapture:
2916     return DeclarationName(Capture.VarID);
2917
2918   case EK_Result:
2919   case EK_Exception:
2920   case EK_New:
2921   case EK_Temporary:
2922   case EK_Base:
2923   case EK_Delegating:
2924   case EK_ArrayElement:
2925   case EK_VectorElement:
2926   case EK_ComplexElement:
2927   case EK_BlockElement:
2928   case EK_CompoundLiteralInit:
2929   case EK_RelatedResult:
2930     return DeclarationName();
2931   }
2932
2933   llvm_unreachable("Invalid EntityKind!");
2934 }
2935
2936 ValueDecl *InitializedEntity::getDecl() const {
2937   switch (getKind()) {
2938   case EK_Variable:
2939   case EK_Member:
2940   case EK_Binding:
2941     return Variable.VariableOrMember;
2942
2943   case EK_Parameter:
2944   case EK_Parameter_CF_Audited:
2945     return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2946
2947   case EK_Result:
2948   case EK_Exception:
2949   case EK_New:
2950   case EK_Temporary:
2951   case EK_Base:
2952   case EK_Delegating:
2953   case EK_ArrayElement:
2954   case EK_VectorElement:
2955   case EK_ComplexElement:
2956   case EK_BlockElement:
2957   case EK_LambdaCapture:
2958   case EK_CompoundLiteralInit:
2959   case EK_RelatedResult:
2960     return nullptr;
2961   }
2962
2963   llvm_unreachable("Invalid EntityKind!");
2964 }
2965
2966 bool InitializedEntity::allowsNRVO() const {
2967   switch (getKind()) {
2968   case EK_Result:
2969   case EK_Exception:
2970     return LocAndNRVO.NRVO;
2971
2972   case EK_Variable:
2973   case EK_Parameter:
2974   case EK_Parameter_CF_Audited:
2975   case EK_Member:
2976   case EK_Binding:
2977   case EK_New:
2978   case EK_Temporary:
2979   case EK_CompoundLiteralInit:
2980   case EK_Base:
2981   case EK_Delegating:
2982   case EK_ArrayElement:
2983   case EK_VectorElement:
2984   case EK_ComplexElement:
2985   case EK_BlockElement:
2986   case EK_LambdaCapture:
2987   case EK_RelatedResult:
2988     break;
2989   }
2990
2991   return false;
2992 }
2993
2994 unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
2995   assert(getParent() != this);
2996   unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
2997   for (unsigned I = 0; I != Depth; ++I)
2998     OS << "`-";
2999
3000   switch (getKind()) {
3001   case EK_Variable: OS << "Variable"; break;
3002   case EK_Parameter: OS << "Parameter"; break;
3003   case EK_Parameter_CF_Audited: OS << "CF audited function Parameter";
3004     break;
3005   case EK_Result: OS << "Result"; break;
3006   case EK_Exception: OS << "Exception"; break;
3007   case EK_Member: OS << "Member"; break;
3008   case EK_Binding: OS << "Binding"; break;
3009   case EK_New: OS << "New"; break;
3010   case EK_Temporary: OS << "Temporary"; break;
3011   case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
3012   case EK_RelatedResult: OS << "RelatedResult"; break;
3013   case EK_Base: OS << "Base"; break;
3014   case EK_Delegating: OS << "Delegating"; break;
3015   case EK_ArrayElement: OS << "ArrayElement " << Index; break;
3016   case EK_VectorElement: OS << "VectorElement " << Index; break;
3017   case EK_ComplexElement: OS << "ComplexElement " << Index; break;
3018   case EK_BlockElement: OS << "Block"; break;
3019   case EK_LambdaCapture:
3020     OS << "LambdaCapture ";
3021     OS << DeclarationName(Capture.VarID);
3022     break;
3023   }
3024
3025   if (auto *D = getDecl()) {
3026     OS << " ";
3027     D->printQualifiedName(OS);
3028   }
3029
3030   OS << " '" << getType().getAsString() << "'\n";
3031
3032   return Depth + 1;
3033 }
3034
3035 LLVM_DUMP_METHOD void InitializedEntity::dump() const {
3036   dumpImpl(llvm::errs());
3037 }
3038
3039 //===----------------------------------------------------------------------===//
3040 // Initialization sequence
3041 //===----------------------------------------------------------------------===//
3042
3043 void InitializationSequence::Step::Destroy() {
3044   switch (Kind) {
3045   case SK_ResolveAddressOfOverloadedFunction:
3046   case SK_CastDerivedToBaseRValue:
3047   case SK_CastDerivedToBaseXValue:
3048   case SK_CastDerivedToBaseLValue:
3049   case SK_BindReference:
3050   case SK_BindReferenceToTemporary:
3051   case SK_FinalCopy:
3052   case SK_ExtraneousCopyToTemporary:
3053   case SK_UserConversion:
3054   case SK_QualificationConversionRValue:
3055   case SK_QualificationConversionXValue:
3056   case SK_QualificationConversionLValue:
3057   case SK_AtomicConversion:
3058   case SK_LValueToRValue:
3059   case SK_ListInitialization:
3060   case SK_UnwrapInitList:
3061   case SK_RewrapInitList:
3062   case SK_ConstructorInitialization:
3063   case SK_ConstructorInitializationFromList:
3064   case SK_ZeroInitialization:
3065   case SK_CAssignment:
3066   case SK_StringInit:
3067   case SK_ObjCObjectConversion:
3068   case SK_ArrayLoopIndex:
3069   case SK_ArrayLoopInit:
3070   case SK_ArrayInit:
3071   case SK_GNUArrayInit:
3072   case SK_ParenthesizedArrayInit:
3073   case SK_PassByIndirectCopyRestore:
3074   case SK_PassByIndirectRestore:
3075   case SK_ProduceObjCObject:
3076   case SK_StdInitializerList:
3077   case SK_StdInitializerListConstructorCall:
3078   case SK_OCLSamplerInit:
3079   case SK_OCLZeroEvent:
3080   case SK_OCLZeroQueue:
3081     break;
3082
3083   case SK_ConversionSequence:
3084   case SK_ConversionSequenceNoNarrowing:
3085     delete ICS;
3086   }
3087 }
3088
3089 bool InitializationSequence::isDirectReferenceBinding() const {
3090   // There can be some lvalue adjustments after the SK_BindReference step.
3091   for (auto I = Steps.rbegin(); I != Steps.rend(); ++I) {
3092     if (I->Kind == SK_BindReference)
3093       return true;
3094     if (I->Kind == SK_BindReferenceToTemporary)
3095       return false;
3096   }
3097   return false;
3098 }
3099
3100 bool InitializationSequence::isAmbiguous() const {
3101   if (!Failed())
3102     return false;
3103
3104   switch (getFailureKind()) {
3105   case FK_TooManyInitsForReference:
3106   case FK_ArrayNeedsInitList:
3107   case FK_ArrayNeedsInitListOrStringLiteral:
3108   case FK_ArrayNeedsInitListOrWideStringLiteral:
3109   case FK_NarrowStringIntoWideCharArray:
3110   case FK_WideStringIntoCharArray:
3111   case FK_IncompatWideStringIntoWideChar:
3112   case FK_AddressOfOverloadFailed: // FIXME: Could do better
3113   case FK_NonConstLValueReferenceBindingToTemporary:
3114   case FK_NonConstLValueReferenceBindingToBitfield:
3115   case FK_NonConstLValueReferenceBindingToVectorElement:
3116   case FK_NonConstLValueReferenceBindingToUnrelated:
3117   case FK_RValueReferenceBindingToLValue:
3118   case FK_ReferenceInitDropsQualifiers:
3119   case FK_ReferenceInitFailed:
3120   case FK_ConversionFailed:
3121   case FK_ConversionFromPropertyFailed:
3122   case FK_TooManyInitsForScalar:
3123   case FK_ReferenceBindingToInitList:
3124   case FK_InitListBadDestinationType:
3125   case FK_DefaultInitOfConst:
3126   case FK_Incomplete:
3127   case FK_ArrayTypeMismatch:
3128   case FK_NonConstantArrayInit:
3129   case FK_ListInitializationFailed:
3130   case FK_VariableLengthArrayHasInitializer:
3131   case FK_PlaceholderType:
3132   case FK_ExplicitConstructor:
3133   case FK_AddressOfUnaddressableFunction:
3134     return false;
3135
3136   case FK_ReferenceInitOverloadFailed:
3137   case FK_UserConversionOverloadFailed:
3138   case FK_ConstructorOverloadFailed:
3139   case FK_ListConstructorOverloadFailed:
3140     return FailedOverloadResult == OR_Ambiguous;
3141   }
3142
3143   llvm_unreachable("Invalid EntityKind!");
3144 }
3145
3146 bool InitializationSequence::isConstructorInitialization() const {
3147   return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
3148 }
3149
3150 void
3151 InitializationSequence
3152 ::AddAddressOverloadResolutionStep(FunctionDecl *Function,
3153                                    DeclAccessPair Found,
3154                                    bool HadMultipleCandidates) {
3155   Step S;
3156   S.Kind = SK_ResolveAddressOfOverloadedFunction;
3157   S.Type = Function->getType();
3158   S.Function.HadMultipleCandidates = HadMultipleCandidates;
3159   S.Function.Function = Function;
3160   S.Function.FoundDecl = Found;
3161   Steps.push_back(S);
3162 }
3163
3164 void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
3165                                                       ExprValueKind VK) {
3166   Step S;
3167   switch (VK) {
3168   case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
3169   case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
3170   case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
3171   }
3172   S.Type = BaseType;
3173   Steps.push_back(S);
3174 }
3175
3176 void InitializationSequence::AddReferenceBindingStep(QualType T,
3177                                                      bool BindingTemporary) {
3178   Step S;
3179   S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
3180   S.Type = T;
3181   Steps.push_back(S);
3182 }
3183
3184 void InitializationSequence::AddFinalCopy(QualType T) {
3185   Step S;
3186   S.Kind = SK_FinalCopy;
3187   S.Type = T;
3188   Steps.push_back(S);
3189 }
3190
3191 void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) {
3192   Step S;
3193   S.Kind = SK_ExtraneousCopyToTemporary;
3194   S.Type = T;
3195   Steps.push_back(S);
3196 }
3197
3198 void
3199 InitializationSequence::AddUserConversionStep(FunctionDecl *Function,
3200                                               DeclAccessPair FoundDecl,
3201                                               QualType T,
3202                                               bool HadMultipleCandidates) {
3203   Step S;
3204   S.Kind = SK_UserConversion;
3205   S.Type = T;
3206   S.Function.HadMultipleCandidates = HadMultipleCandidates;
3207   S.Function.Function = Function;
3208   S.Function.FoundDecl = FoundDecl;
3209   Steps.push_back(S);
3210 }
3211
3212 void InitializationSequence::AddQualificationConversionStep(QualType Ty,
3213                                                             ExprValueKind VK) {
3214   Step S;
3215   S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
3216   switch (VK) {
3217   case VK_RValue:
3218     S.Kind = SK_QualificationConversionRValue;
3219     break;
3220   case VK_XValue:
3221     S.Kind = SK_QualificationConversionXValue;
3222     break;
3223   case VK_LValue:
3224     S.Kind = SK_QualificationConversionLValue;
3225     break;
3226   }
3227   S.Type = Ty;
3228   Steps.push_back(S);
3229 }
3230
3231 void InitializationSequence::AddAtomicConversionStep(QualType Ty) {
3232   Step S;
3233   S.Kind = SK_AtomicConversion;
3234   S.Type = Ty;
3235   Steps.push_back(S);
3236 }
3237
3238 void InitializationSequence::AddLValueToRValueStep(QualType Ty) {
3239   assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
3240
3241   Step S;
3242   S.Kind = SK_LValueToRValue;
3243   S.Type = Ty;
3244   Steps.push_back(S);
3245 }
3246
3247 void InitializationSequence::AddConversionSequenceStep(
3248     const ImplicitConversionSequence &ICS, QualType T,
3249     bool TopLevelOfInitList) {
3250   Step S;
3251   S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing
3252                               : SK_ConversionSequence;
3253   S.Type = T;
3254   S.ICS = new ImplicitConversionSequence(ICS);
3255   Steps.push_back(S);
3256 }
3257
3258 void InitializationSequence::AddListInitializationStep(QualType T) {
3259   Step S;
3260   S.Kind = SK_ListInitialization;
3261   S.Type = T;
3262   Steps.push_back(S);
3263 }
3264
3265 void InitializationSequence::AddConstructorInitializationStep(
3266     DeclAccessPair FoundDecl, CXXConstructorDecl *Constructor, QualType T,
3267     bool HadMultipleCandidates, bool FromInitList, bool AsInitList) {
3268   Step S;
3269   S.Kind = FromInitList ? AsInitList ? SK_StdInitializerListConstructorCall
3270                                      : SK_ConstructorInitializationFromList
3271                         : SK_ConstructorInitialization;
3272   S.Type = T;
3273   S.Function.HadMultipleCandidates = HadMultipleCandidates;
3274   S.Function.Function = Constructor;
3275   S.Function.FoundDecl = FoundDecl;
3276   Steps.push_back(S);
3277 }
3278
3279 void InitializationSequence::AddZeroInitializationStep(QualType T) {
3280   Step S;
3281   S.Kind = SK_ZeroInitialization;
3282   S.Type = T;
3283   Steps.push_back(S);
3284 }
3285
3286 void InitializationSequence::AddCAssignmentStep(QualType T) {
3287   Step S;
3288   S.Kind = SK_CAssignment;
3289   S.Type = T;
3290   Steps.push_back(S);
3291 }
3292
3293 void InitializationSequence::AddStringInitStep(QualType T) {
3294   Step S;
3295   S.Kind = SK_StringInit;
3296   S.Type = T;
3297   Steps.push_back(S);
3298 }
3299
3300 void InitializationSequence::AddObjCObjectConversionStep(QualType T) {
3301   Step S;
3302   S.Kind = SK_ObjCObjectConversion;
3303   S.Type = T;
3304   Steps.push_back(S);
3305 }
3306
3307 void InitializationSequence::AddArrayInitStep(QualType T, bool IsGNUExtension) {
3308   Step S;
3309   S.Kind = IsGNUExtension ? SK_GNUArrayInit : SK_ArrayInit;
3310   S.Type = T;
3311   Steps.push_back(S);
3312 }
3313
3314 void InitializationSequence::AddArrayInitLoopStep(QualType T, QualType EltT) {
3315   Step S;
3316   S.Kind = SK_ArrayLoopIndex;
3317   S.Type = EltT;
3318   Steps.insert(Steps.begin(), S);
3319
3320   S.Kind = SK_ArrayLoopInit;
3321   S.Type = T;
3322   Steps.push_back(S);
3323 }
3324
3325 void InitializationSequence::AddParenthesizedArrayInitStep(QualType T) {
3326   Step S;
3327   S.Kind = SK_ParenthesizedArrayInit;
3328   S.Type = T;
3329   Steps.push_back(S);
3330 }
3331
3332 void InitializationSequence::AddPassByIndirectCopyRestoreStep(QualType type,
3333                                                               bool shouldCopy) {
3334   Step s;
3335   s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
3336                        : SK_PassByIndirectRestore);
3337   s.Type = type;
3338   Steps.push_back(s);
3339 }
3340
3341 void InitializationSequence::AddProduceObjCObjectStep(QualType T) {
3342   Step S;
3343   S.Kind = SK_ProduceObjCObject;
3344   S.Type = T;
3345   Steps.push_back(S);
3346 }
3347
3348 void InitializationSequence::AddStdInitializerListConstructionStep(QualType T) {
3349   Step S;
3350   S.Kind = SK_StdInitializerList;
3351   S.Type = T;
3352   Steps.push_back(S);
3353 }
3354
3355 void InitializationSequence::AddOCLSamplerInitStep(QualType T) {
3356   Step S;
3357   S.Kind = SK_OCLSamplerInit;
3358   S.Type = T;
3359   Steps.push_back(S);
3360 }
3361
3362 void InitializationSequence::AddOCLZeroEventStep(QualType T) {
3363   Step S;
3364   S.Kind = SK_OCLZeroEvent;
3365   S.Type = T;
3366   Steps.push_back(S);
3367 }
3368
3369 void InitializationSequence::AddOCLZeroQueueStep(QualType T) {
3370   Step S;
3371   S.Kind = SK_OCLZeroQueue;
3372   S.Type = T;
3373   Steps.push_back(S);
3374 }
3375
3376 void InitializationSequence::RewrapReferenceInitList(QualType T,
3377                                                      InitListExpr *Syntactic) {
3378   assert(Syntactic->getNumInits() == 1 &&
3379          "Can only rewrap trivial init lists.");
3380   Step S;
3381   S.Kind = SK_UnwrapInitList;
3382   S.Type = Syntactic->getInit(0)->getType();
3383   Steps.insert(Steps.begin(), S);
3384
3385   S.Kind = SK_RewrapInitList;
3386   S.Type = T;
3387   S.WrappingSyntacticList = Syntactic;
3388   Steps.push_back(S);
3389 }
3390
3391 void InitializationSequence::SetOverloadFailure(FailureKind Failure,
3392                                                 OverloadingResult Result) {
3393   setSequenceKind(FailedSequence);
3394   this->Failure = Failure;
3395   this->FailedOverloadResult = Result;
3396 }
3397
3398 //===----------------------------------------------------------------------===//
3399 // Attempt initialization
3400 //===----------------------------------------------------------------------===//
3401
3402 /// Tries to add a zero initializer. Returns true if that worked.
3403 static bool
3404 maybeRecoverWithZeroInitialization(Sema &S, InitializationSequence &Sequence,
3405                                    const InitializedEntity &Entity) {
3406   if (Entity.getKind() != InitializedEntity::EK_Variable)
3407     return false;
3408
3409   VarDecl *VD = cast<VarDecl>(Entity.getDecl());
3410   if (VD->getInit() || VD->getLocEnd().isMacroID())
3411     return false;
3412
3413   QualType VariableTy = VD->getType().getCanonicalType();
3414   SourceLocation Loc = S.getLocForEndOfToken(VD->getLocEnd());
3415   std::string Init = S.getFixItZeroInitializerForType(VariableTy, Loc);
3416   if (!Init.empty()) {
3417     Sequence.AddZeroInitializationStep(Entity.getType());
3418     Sequence.SetZeroInitializationFixit(Init, Loc);
3419     return true;
3420   }
3421   return false;
3422 }
3423
3424 static void MaybeProduceObjCObject(Sema &S,
3425                                    InitializationSequence &Sequence,
3426                                    const InitializedEntity &Entity) {
3427   if (!S.getLangOpts().ObjCAutoRefCount) return;
3428
3429   /// When initializing a parameter, produce the value if it's marked
3430   /// __attribute__((ns_consumed)).
3431   if (Entity.isParameterKind()) {
3432     if (!Entity.isParameterConsumed())
3433       return;
3434
3435     assert(Entity.getType()->isObjCRetainableType() &&
3436            "consuming an object of unretainable type?");
3437     Sequence.AddProduceObjCObjectStep(Entity.getType());
3438
3439   /// When initializing a return value, if the return type is a
3440   /// retainable type, then returns need to immediately retain the
3441   /// object.  If an autorelease is required, it will be done at the
3442   /// last instant.
3443   } else if (Entity.getKind() == InitializedEntity::EK_Result) {
3444     if (!Entity.getType()->isObjCRetainableType())
3445       return;
3446
3447     Sequence.AddProduceObjCObjectStep(Entity.getType());
3448   }
3449 }
3450
3451 static void TryListInitialization(Sema &S,
3452                                   const InitializedEntity &Entity,
3453                                   const InitializationKind &Kind,
3454                                   InitListExpr *InitList,
3455                                   InitializationSequence &Sequence,
3456                                   bool TreatUnavailableAsInvalid);
3457
3458 /// \brief When initializing from init list via constructor, handle
3459 /// initialization of an object of type std::initializer_list<T>.
3460 ///
3461 /// \return true if we have handled initialization of an object of type
3462 /// std::initializer_list<T>, false otherwise.
3463 static bool TryInitializerListConstruction(Sema &S,
3464                                            InitListExpr *List,
3465                                            QualType DestType,
3466                                            InitializationSequence &Sequence,
3467                                            bool TreatUnavailableAsInvalid) {
3468   QualType E;
3469   if (!S.isStdInitializerList(DestType, &E))
3470     return false;
3471
3472   if (!S.isCompleteType(List->getExprLoc(), E)) {
3473     Sequence.setIncompleteTypeFailure(E);
3474     return true;
3475   }
3476
3477   // Try initializing a temporary array from the init list.
3478   QualType ArrayType = S.Context.getConstantArrayType(
3479       E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
3480                                  List->getNumInits()),
3481       clang::ArrayType::Normal, 0);
3482   InitializedEntity HiddenArray =
3483       InitializedEntity::InitializeTemporary(ArrayType);
3484   InitializationKind Kind =
3485       InitializationKind::CreateDirectList(List->getExprLoc());
3486   TryListInitialization(S, HiddenArray, Kind, List, Sequence,
3487                         TreatUnavailableAsInvalid);
3488   if (Sequence)
3489     Sequence.AddStdInitializerListConstructionStep(DestType);
3490   return true;
3491 }
3492
3493 /// Determine if the constructor has the signature of a copy or move
3494 /// constructor for the type T of the class in which it was found. That is,
3495 /// determine if its first parameter is of type T or reference to (possibly
3496 /// cv-qualified) T.
3497 static bool hasCopyOrMoveCtorParam(ASTContext &Ctx,
3498                                    const ConstructorInfo &Info) {
3499   if (Info.Constructor->getNumParams() == 0)
3500     return false;
3501
3502   QualType ParmT =
3503       Info.Constructor->getParamDecl(0)->getType().getNonReferenceType();
3504   QualType ClassT =
3505       Ctx.getRecordType(cast<CXXRecordDecl>(Info.FoundDecl->getDeclContext()));
3506
3507   return Ctx.hasSameUnqualifiedType(ParmT, ClassT);
3508 }
3509
3510 static OverloadingResult
3511 ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc,
3512                            MultiExprArg Args,
3513                            OverloadCandidateSet &CandidateSet,
3514                            DeclContext::lookup_result Ctors,
3515                            OverloadCandidateSet::iterator &Best,
3516                            bool CopyInitializing, bool AllowExplicit,
3517                            bool OnlyListConstructors, bool IsListInit,
3518                            bool SecondStepOfCopyInit = false) {
3519   CandidateSet.clear();
3520
3521   for (NamedDecl *D : Ctors) {
3522     auto Info = getConstructorInfo(D);
3523     if (!Info.Constructor || Info.Constructor->isInvalidDecl())
3524       continue;
3525
3526     if (!AllowExplicit && Info.Constructor->isExplicit())
3527       continue;
3528
3529     if (OnlyListConstructors && !S.isInitListConstructor(Info.Constructor))
3530       continue;
3531
3532     // C++11 [over.best.ics]p4:
3533     //   ... and the constructor or user-defined conversion function is a
3534     //   candidate by
3535     //   - 13.3.1.3, when the argument is the temporary in the second step
3536     //     of a class copy-initialization, or
3537     //   - 13.3.1.4, 13.3.1.5, or 13.3.1.6 (in all cases), [not handled here]
3538     //   - the second phase of 13.3.1.7 when the initializer list has exactly
3539     //     one element that is itself an initializer list, and the target is
3540     //     the first parameter of a constructor of class X, and the conversion
3541     //     is to X or reference to (possibly cv-qualified X),
3542     //   user-defined conversion sequences are not considered.
3543     bool SuppressUserConversions =
3544         SecondStepOfCopyInit ||
3545         (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
3546          hasCopyOrMoveCtorParam(S.Context, Info));
3547
3548     if (Info.ConstructorTmpl)
3549       S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
3550                                      /*ExplicitArgs*/ nullptr, Args,
3551                                      CandidateSet, SuppressUserConversions);
3552     else {
3553       // C++ [over.match.copy]p1:
3554       //   - When initializing a temporary to be bound to the first parameter
3555       //     of a constructor [for type T] that takes a reference to possibly
3556       //     cv-qualified T as its first argument, called with a single
3557       //     argument in the context of direct-initialization, explicit
3558       //     conversion functions are also considered.
3559       // FIXME: What if a constructor template instantiates to such a signature?
3560       bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
3561                                Args.size() == 1 &&
3562                                hasCopyOrMoveCtorParam(S.Context, Info);
3563       S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, Args,
3564                              CandidateSet, SuppressUserConversions,
3565                              /*PartialOverloading=*/false,
3566                              /*AllowExplicit=*/AllowExplicitConv);
3567     }
3568   }
3569
3570   // Perform overload resolution and return the result.
3571   return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3572 }
3573
3574 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3575 /// enumerates the constructors of the initialized entity and performs overload
3576 /// resolution to select the best.
3577 /// \param DestType       The destination class type.
3578 /// \param DestArrayType  The destination type, which is either DestType or
3579 ///                       a (possibly multidimensional) array of DestType.
3580 /// \param IsListInit     Is this list-initialization?
3581 /// \param IsInitListCopy Is this non-list-initialization resulting from a
3582 ///                       list-initialization from {x} where x is the same
3583 ///                       type as the entity?
3584 static void TryConstructorInitialization(Sema &S,
3585                                          const InitializedEntity &Entity,
3586                                          const InitializationKind &Kind,
3587                                          MultiExprArg Args, QualType DestType,
3588                                          QualType DestArrayType,
3589                                          InitializationSequence &Sequence,
3590                                          bool IsListInit = false,
3591                                          bool IsInitListCopy = false) {
3592   assert(((!IsListInit && !IsInitListCopy) ||
3593           (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
3594          "IsListInit/IsInitListCopy must come with a single initializer list "
3595          "argument.");
3596   InitListExpr *ILE =
3597       (IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) : nullptr;
3598   MultiExprArg UnwrappedArgs =
3599       ILE ? MultiExprArg(ILE->getInits(), ILE->getNumInits()) : Args;
3600
3601   // The type we're constructing needs to be complete.
3602   if (!S.isCompleteType(Kind.getLocation(), DestType)) {
3603     Sequence.setIncompleteTypeFailure(DestType);
3604     return;
3605   }
3606
3607   // C++1z [dcl.init]p17:
3608   //     - If the initializer expression is a prvalue and the cv-unqualified
3609   //       version of the source type is the same class as the class of the
3610   //       destination, the initializer expression is used to initialize the
3611   //       destination object.
3612   // Per DR (no number yet), this does not apply when initializing a base
3613   // class or delegating to another constructor from a mem-initializer.
3614   if (S.getLangOpts().CPlusPlus1z &&
3615       Entity.getKind() != InitializedEntity::EK_Base &&
3616       Entity.getKind() != InitializedEntity::EK_Delegating &&
3617       UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isRValue() &&
3618       S.Context.hasSameUnqualifiedType(UnwrappedArgs[0]->getType(), DestType)) {
3619     // Convert qualifications if necessary.
3620     Sequence.AddQualificationConversionStep(DestType, VK_RValue);
3621     if (ILE)
3622       Sequence.RewrapReferenceInitList(DestType, ILE);
3623     return;
3624   }
3625
3626   const RecordType *DestRecordType = DestType->getAs<RecordType>();
3627   assert(DestRecordType && "Constructor initialization requires record type");
3628   CXXRecordDecl *DestRecordDecl
3629     = cast<CXXRecordDecl>(DestRecordType->getDecl());
3630
3631   // Build the candidate set directly in the initialization sequence
3632   // structure, so that it will persist if we fail.
3633   OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3634
3635   // Determine whether we are allowed to call explicit constructors or
3636   // explicit conversion operators.
3637   bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
3638   bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
3639
3640   //   - Otherwise, if T is a class type, constructors are considered. The
3641   //     applicable constructors are enumerated, and the best one is chosen
3642   //     through overload resolution.
3643   DeclContext::lookup_result Ctors = S.LookupConstructors(DestRecordDecl);
3644
3645   OverloadingResult Result = OR_No_Viable_Function;
3646   OverloadCandidateSet::iterator Best;
3647   bool AsInitializerList = false;
3648
3649   // C++11 [over.match.list]p1, per DR1467:
3650   //   When objects of non-aggregate type T are list-initialized, such that
3651   //   8.5.4 [dcl.init.list] specifies that overload resolution is performed
3652   //   according to the rules in this section, overload resolution selects
3653   //   the constructor in two phases:
3654   //
3655   //   - Initially, the candidate functions are the initializer-list
3656   //     constructors of the class T and the argument list consists of the
3657   //     initializer list as a single argument.
3658   if (IsListInit) {
3659     AsInitializerList = true;
3660
3661     // If the initializer list has no elements and T has a default constructor,
3662     // the first phase is omitted.
3663     if (!(UnwrappedArgs.empty() && DestRecordDecl->hasDefaultConstructor()))
3664       Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3665                                           CandidateSet, Ctors, Best,
3666                                           CopyInitialization, AllowExplicit,
3667                                           /*OnlyListConstructor=*/true,
3668                                           IsListInit);
3669   }
3670
3671   // C++11 [over.match.list]p1:
3672   //   - If no viable initializer-list constructor is found, overload resolution
3673   //     is performed again, where the candidate functions are all the
3674   //     constructors of the class T and the argument list consists of the
3675   //     elements of the initializer list.
3676   if (Result == OR_No_Viable_Function) {
3677     AsInitializerList = false;
3678     Result = ResolveConstructorOverload(S, Kind.getLocation(), UnwrappedArgs,
3679                                         CandidateSet, Ctors, Best,
3680                                         CopyInitialization, AllowExplicit,
3681                                         /*OnlyListConstructors=*/false,
3682                                         IsListInit);
3683   }
3684   if (Result) {
3685     Sequence.SetOverloadFailure(IsListInit ?
3686                       InitializationSequence::FK_ListConstructorOverloadFailed :
3687                       InitializationSequence::FK_ConstructorOverloadFailed,
3688                                 Result);
3689     return;
3690   }
3691
3692   // C++11 [dcl.init]p6:
3693   //   If a program calls for the default initialization of an object
3694   //   of a const-qualified type T, T shall be a class type with a
3695   //   user-provided default constructor.
3696   // C++ core issue 253 proposal:
3697   //   If the implicit default constructor initializes all subobjects, no
3698   //   initializer should be required.
3699   // The 253 proposal is for example needed to process libstdc++ headers in 5.x.
3700   CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3701   if (Kind.getKind() == InitializationKind::IK_Default &&
3702       Entity.getType().isConstQualified()) {
3703     if (!CtorDecl->getParent()->allowConstDefaultInit()) {
3704       if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
3705         Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
3706       return;
3707     }
3708   }
3709
3710   // C++11 [over.match.list]p1:
3711   //   In copy-list-initialization, if an explicit constructor is chosen, the
3712   //   initializer is ill-formed.
3713   if (IsListInit && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3714     Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor);
3715     return;
3716   }
3717
3718   // Add the constructor initialization step. Any cv-qualification conversion is
3719   // subsumed by the initialization.
3720   bool HadMultipleCandidates = (CandidateSet.size() > 1);
3721   Sequence.AddConstructorInitializationStep(
3722       Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,
3723       IsListInit | IsInitListCopy, AsInitializerList);
3724 }
3725
3726 static bool
3727 ResolveOverloadedFunctionForReferenceBinding(Sema &S,
3728                                              Expr *Initializer,
3729                                              QualType &SourceType,
3730                                              QualType &UnqualifiedSourceType,
3731                                              QualType UnqualifiedTargetType,
3732                                              InitializationSequence &Sequence) {
3733   if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
3734         S.Context.OverloadTy) {
3735     DeclAccessPair Found;
3736     bool HadMultipleCandidates = false;
3737     if (FunctionDecl *Fn
3738         = S.ResolveAddressOfOverloadedFunction(Initializer,
3739                                                UnqualifiedTargetType,
3740                                                false, Found,
3741                                                &HadMultipleCandidates)) {
3742       Sequence.AddAddressOverloadResolutionStep(Fn, Found,
3743                                                 HadMultipleCandidates);
3744       SourceType = Fn->getType();
3745       UnqualifiedSourceType = SourceType.getUnqualifiedType();
3746     } else if (!UnqualifiedTargetType->isRecordType()) {
3747       Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3748       return true;
3749     }
3750   }
3751   return false;
3752 }
3753
3754 static void TryReferenceInitializationCore(Sema &S,
3755                                            const InitializedEntity &Entity,
3756                                            const InitializationKind &Kind,
3757                                            Expr *Initializer,
3758                                            QualType cv1T1, QualType T1,
3759                                            Qualifiers T1Quals,
3760                                            QualType cv2T2, QualType T2,
3761                                            Qualifiers T2Quals,
3762                                            InitializationSequence &Sequence);
3763
3764 static void TryValueInitialization(Sema &S,
3765                                    const InitializedEntity &Entity,
3766                                    const InitializationKind &Kind,
3767                                    InitializationSequence &Sequence,
3768                                    InitListExpr *InitList = nullptr);
3769
3770 /// \brief Attempt list initialization of a reference.
3771 static void TryReferenceListInitialization(Sema &S,
3772                                            const InitializedEntity &Entity,
3773                                            const InitializationKind &Kind,
3774                                            InitListExpr *InitList,
3775                                            InitializationSequence &Sequence,
3776                                            bool TreatUnavailableAsInvalid) {
3777   // First, catch C++03 where this isn't possible.
3778   if (!S.getLangOpts().CPlusPlus11) {
3779     Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
3780     return;
3781   }
3782   // Can't reference initialize a compound literal.
3783   if (Entity.getKind() == InitializedEntity::EK_CompoundLiteralInit) {
3784     Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
3785     return;
3786   }
3787
3788   QualType DestType = Entity.getType();
3789   QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3790   Qualifiers T1Quals;
3791   QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3792
3793   // Reference initialization via an initializer list works thus:
3794   // If the initializer list consists of a single element that is
3795   // reference-related to the referenced type, bind directly to that element
3796   // (possibly creating temporaries).
3797   // Otherwise, initialize a temporary with the initializer list and
3798   // bind to that.
3799   if (InitList->getNumInits() == 1) {
3800     Expr *Initializer = InitList->getInit(0);
3801     QualType cv2T2 = Initializer->getType();
3802     Qualifiers T2Quals;
3803     QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3804
3805     // If this fails, creating a temporary wouldn't work either.
3806     if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3807                                                      T1, Sequence))
3808       return;
3809
3810     SourceLocation DeclLoc = Initializer->getLocStart();
3811     bool dummy1, dummy2, dummy3;
3812     Sema::ReferenceCompareResult RefRelationship
3813       = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3814                                        dummy2, dummy3);
3815     if (RefRelationship >= Sema::Ref_Related) {
3816       // Try to bind the reference here.
3817       TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3818                                      T1Quals, cv2T2, T2, T2Quals, Sequence);
3819       if (Sequence)
3820         Sequence.RewrapReferenceInitList(cv1T1, InitList);
3821       return;
3822     }
3823
3824     // Update the initializer if we've resolved an overloaded function.
3825     if (Sequence.step_begin() != Sequence.step_end())
3826       Sequence.RewrapReferenceInitList(cv1T1, InitList);
3827   }
3828
3829   // Not reference-related. Create a temporary and bind to that.
3830   InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3831
3832   TryListInitialization(S, TempEntity, Kind, InitList, Sequence,
3833                         TreatUnavailableAsInvalid);
3834   if (Sequence) {
3835     if (DestType->isRValueReferenceType() ||
3836         (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3837       Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3838     else
3839       Sequence.SetFailed(
3840           InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
3841   }
3842 }
3843
3844 /// \brief Attempt list initialization (C++0x [dcl.init.list])
3845 static void TryListInitialization(Sema &S,
3846                                   const InitializedEntity &Entity,
3847                                   const InitializationKind &Kind,
3848                                   InitListExpr *InitList,
3849                                   InitializationSequence &Sequence,
3850                                   bool TreatUnavailableAsInvalid) {
3851   QualType DestType = Entity.getType();
3852
3853   // C++ doesn't allow scalar initialization with more than one argument.
3854   // But C99 complex numbers are scalars and it makes sense there.
3855   if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
3856       !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
3857     Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar);
3858     return;
3859   }
3860   if (DestType->isReferenceType()) {
3861     TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence,
3862                                    TreatUnavailableAsInvalid);
3863     return;
3864   }
3865
3866   if (DestType->isRecordType() &&
3867       !S.isCompleteType(InitList->getLocStart(), DestType)) {
3868     Sequence.setIncompleteTypeFailure(DestType);
3869     return;
3870   }
3871
3872   // C++11 [dcl.init.list]p3, per DR1467:
3873   // - If T is a class type and the initializer list has a single element of
3874   //   type cv U, where U is T or a class derived from T, the object is
3875   //   initialized from that element (by copy-initialization for
3876   //   copy-list-initialization, or by direct-initialization for
3877   //   direct-list-initialization).
3878   // - Otherwise, if T is a character array and the initializer list has a
3879   //   single element that is an appropriately-typed string literal
3880   //   (8.5.2 [dcl.init.string]), initialization is performed as described
3881   //   in that section.
3882   // - Otherwise, if T is an aggregate, [...] (continue below).
3883   if (S.getLangOpts().CPlusPlus11 && InitList->getNumInits() == 1) {
3884     if (DestType->isRecordType()) {
3885       QualType InitType = InitList->getInit(0)->getType();
3886       if (S.Context.hasSameUnqualifiedType(InitType, DestType) ||
3887           S.IsDerivedFrom(InitList->getLocStart(), InitType, DestType)) {
3888         Expr *InitListAsExpr = InitList;
3889         TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
3890                                      DestType, Sequence,
3891                                      /*InitListSyntax*/false,
3892                                      /*IsInitListCopy*/true);
3893         return;
3894       }
3895     }
3896     if (const ArrayType *DestAT = S.Context.getAsArrayType(DestType)) {
3897       Expr *SubInit[1] = {InitList->getInit(0)};
3898       if (!isa<VariableArrayType>(DestAT) &&
3899           IsStringInit(SubInit[0], DestAT, S.Context) == SIF_None) {
3900         InitializationKind SubKind =
3901             Kind.getKind() == InitializationKind::IK_DirectList
3902                 ? InitializationKind::CreateDirect(Kind.getLocation(),
3903                                                    InitList->getLBraceLoc(),
3904                                                    InitList->getRBraceLoc())
3905                 : Kind;
3906         Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3907                                 /*TopLevelOfInitList*/ true,
3908                                 TreatUnavailableAsInvalid);
3909
3910         // TryStringLiteralInitialization() (in InitializeFrom()) will fail if
3911         // the element is not an appropriately-typed string literal, in which
3912         // case we should proceed as in C++11 (below).
3913         if (Sequence) {
3914           Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3915           return;
3916         }
3917       }
3918     }
3919   }
3920
3921   // C++11 [dcl.init.list]p3:
3922   //   - If T is an aggregate, aggregate initialization is performed.
3923   if ((DestType->isRecordType() && !DestType->isAggregateType()) ||
3924       (S.getLangOpts().CPlusPlus11 &&
3925        S.isStdInitializerList(DestType, nullptr))) {
3926     if (S.getLangOpts().CPlusPlus11) {
3927       //   - Otherwise, if the initializer list has no elements and T is a
3928       //     class type with a default constructor, the object is
3929       //     value-initialized.
3930       if (InitList->getNumInits() == 0) {
3931         CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
3932         if (RD->hasDefaultConstructor()) {
3933           TryValueInitialization(S, Entity, Kind, Sequence, InitList);
3934           return;
3935         }
3936       }
3937
3938       //   - Otherwise, if T is a specialization of std::initializer_list<E>,
3939       //     an initializer_list object constructed [...]
3940       if (TryInitializerListConstruction(S, InitList, DestType, Sequence,
3941                                          TreatUnavailableAsInvalid))
3942         return;
3943
3944       //   - Otherwise, if T is a class type, constructors are considered.
3945       Expr *InitListAsExpr = InitList;
3946       TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
3947                                    DestType, Sequence, /*InitListSyntax*/true);
3948     } else
3949       Sequence.SetFailed(InitializationSequence::FK_InitListBadDestinationType);
3950     return;
3951   }
3952
3953   if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() &&
3954       InitList->getNumInits() == 1) {
3955     Expr *E = InitList->getInit(0);
3956
3957     //   - Otherwise, if T is an enumeration with a fixed underlying type,
3958     //     the initializer-list has a single element v, and the initialization
3959     //     is direct-list-initialization, the object is initialized with the
3960     //     value T(v); if a narrowing conversion is required to convert v to
3961     //     the underlying type of T, the program is ill-formed.
3962     auto *ET = DestType->getAs<EnumType>();
3963     if (S.getLangOpts().CPlusPlus1z &&
3964         Kind.getKind() == InitializationKind::IK_DirectList &&
3965         ET && ET->getDecl()->isFixed() &&
3966         !S.Context.hasSameUnqualifiedType(E->getType(), DestType) &&
3967         (E->getType()->isIntegralOrEnumerationType() ||
3968          E->getType()->isFloatingType())) {
3969       // There are two ways that T(v) can work when T is an enumeration type.
3970       // If there is either an implicit conversion sequence from v to T or
3971       // a conversion function that can convert from v to T, then we use that.
3972       // Otherwise, if v is of integral, enumeration, or floating-point type,
3973       // it is converted to the enumeration type via its underlying type.
3974       // There is no overlap possible between these two cases (except when the
3975       // source value is already of the destination type), and the first
3976       // case is handled by the general case for single-element lists below.
3977       ImplicitConversionSequence ICS;
3978       ICS.setStandard();
3979       ICS.Standard.setAsIdentityConversion();
3980       // If E is of a floating-point type, then the conversion is ill-formed
3981       // due to narrowing, but go through the motions in order to produce the
3982       // right diagnostic.
3983       ICS.Standard.Second = E->getType()->isFloatingType()
3984                                 ? ICK_Floating_Integral
3985                                 : ICK_Integral_Conversion;
3986       ICS.Standard.setFromType(E->getType());
3987       ICS.Standard.setToType(0, E->getType());
3988       ICS.Standard.setToType(1, DestType);
3989       ICS.Standard.setToType(2, DestType);
3990       Sequence.AddConversionSequenceStep(ICS, ICS.Standard.getToType(2),
3991                                          /*TopLevelOfInitList*/true);
3992       Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3993       return;
3994     }
3995
3996     //   - Otherwise, if the initializer list has a single element of type E
3997     //     [...references are handled above...], the object or reference is
3998     //     initialized from that element (by copy-initialization for
3999     //     copy-list-initialization, or by direct-initialization for
4000     //     direct-list-initialization); if a narrowing conversion is required
4001     //     to convert the element to T, the program is ill-formed.
4002     //
4003     // Per core-24034, this is direct-initialization if we were performing
4004     // direct-list-initialization and copy-initialization otherwise.
4005     // We can't use InitListChecker for this, because it always performs
4006     // copy-initialization. This only matters if we might use an 'explicit'
4007     // conversion operator, so we only need to handle the cases where the source
4008     // is of record type.
4009     if (InitList->getInit(0)->getType()->isRecordType()) {
4010       InitializationKind SubKind =
4011           Kind.getKind() == InitializationKind::IK_DirectList
4012               ? InitializationKind::CreateDirect(Kind.getLocation(),
4013                                                  InitList->getLBraceLoc(),
4014                                                  InitList->getRBraceLoc())
4015               : Kind;
4016       Expr *SubInit[1] = { InitList->getInit(0) };
4017       Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
4018                               /*TopLevelOfInitList*/true,
4019                               TreatUnavailableAsInvalid);
4020       if (Sequence)
4021         Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
4022       return;
4023     }
4024   }
4025
4026   InitListChecker CheckInitList(S, Entity, InitList,
4027           DestType, /*VerifyOnly=*/true, TreatUnavailableAsInvalid);
4028   if (CheckInitList.HadError()) {
4029     Sequence.SetFailed(InitializationSequence::FK_ListInitializationFailed);
4030     return;
4031   }
4032
4033   // Add the list initialization step with the built init list.
4034   Sequence.AddListInitializationStep(DestType);
4035 }
4036
4037 /// \brief Try a reference initialization that involves calling a conversion
4038 /// function.
4039 static OverloadingResult TryRefInitWithConversionFunction(
4040     Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind,
4041     Expr *Initializer, bool AllowRValues, bool IsLValueRef,
4042     InitializationSequence &Sequence) {
4043   QualType DestType = Entity.getType();
4044   QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
4045   QualType T1 = cv1T1.getUnqualifiedType();
4046   QualType cv2T2 = Initializer->getType();
4047   QualType T2 = cv2T2.getUnqualifiedType();
4048
4049   bool DerivedToBase;
4050   bool ObjCConversion;
4051   bool ObjCLifetimeConversion;
4052   assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
4053                                          T1, T2, DerivedToBase,
4054                                          ObjCConversion,
4055                                          ObjCLifetimeConversion) &&
4056          "Must have incompatible references when binding via conversion");
4057   (void)DerivedToBase;
4058   (void)ObjCConversion;
4059   (void)ObjCLifetimeConversion;
4060
4061   // Build the candidate set directly in the initialization sequence
4062   // structure, so that it will persist if we fail.
4063   OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4064   CandidateSet.clear();
4065
4066   // Determine whether we are allowed to call explicit constructors or
4067   // explicit conversion operators.
4068   bool AllowExplicit = Kind.AllowExplicit();
4069   bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
4070
4071   const RecordType *T1RecordType = nullptr;
4072   if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
4073       S.isCompleteType(Kind.getLocation(), T1)) {
4074     // The type we're converting to is a class type. Enumerate its constructors
4075     // to see if there is a suitable conversion.
4076     CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
4077
4078     for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) {
4079       auto Info = getConstructorInfo(D);
4080       if (!Info.Constructor)
4081         continue;
4082
4083       if (!Info.Constructor->isInvalidDecl() &&
4084           Info.Constructor->isConvertingConstructor(AllowExplicit)) {
4085         if (Info.ConstructorTmpl)
4086           S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
4087                                          /*ExplicitArgs*/ nullptr,
4088                                          Initializer, CandidateSet,
4089                                          /*SuppressUserConversions=*/true);
4090         else
4091           S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
4092                                  Initializer, CandidateSet,
4093                                  /*SuppressUserConversions=*/true);
4094       }
4095     }
4096   }
4097   if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
4098     return OR_No_Viable_Function;
4099
4100   const RecordType *T2RecordType = nullptr;
4101   if ((T2RecordType = T2->getAs<RecordType>()) &&
4102       S.isCompleteType(Kind.getLocation(), T2)) {
4103     // The type we're converting from is a class type, enumerate its conversion
4104     // functions.
4105     CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
4106
4107     const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4108     for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4109       NamedDecl *D = *I;
4110       CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4111       if (isa<UsingShadowDecl>(D))
4112         D = cast<UsingShadowDecl>(D)->getTargetDecl();
4113
4114       FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4115       CXXConversionDecl *Conv;
4116       if (ConvTemplate)
4117         Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4118       else
4119         Conv = cast<CXXConversionDecl>(D);
4120
4121       // If the conversion function doesn't return a reference type,
4122       // it can't be considered for this conversion unless we're allowed to
4123       // consider rvalues.
4124       // FIXME: Do we need to make sure that we only consider conversion
4125       // candidates with reference-compatible results? That might be needed to
4126       // break recursion.
4127       if ((AllowExplicitConvs || !Conv->isExplicit()) &&
4128           (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
4129         if (ConvTemplate)
4130           S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4131                                            ActingDC, Initializer,
4132                                            DestType, CandidateSet,
4133                                            /*AllowObjCConversionOnExplicit=*/
4134                                              false);
4135         else
4136           S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4137                                    Initializer, DestType, CandidateSet,
4138                                    /*AllowObjCConversionOnExplicit=*/false);
4139       }
4140     }
4141   }
4142   if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
4143     return OR_No_Viable_Function;
4144
4145   SourceLocation DeclLoc = Initializer->getLocStart();
4146
4147   // Perform overload resolution. If it fails, return the failed result.
4148   OverloadCandidateSet::iterator Best;
4149   if (OverloadingResult Result
4150         = CandidateSet.BestViableFunction(S, DeclLoc, Best, true))
4151     return Result;
4152
4153   FunctionDecl *Function = Best->Function;
4154   // This is the overload that will be used for this initialization step if we
4155   // use this initialization. Mark it as referenced.
4156   Function->setReferenced();
4157
4158   // Compute the returned type and value kind of the conversion.
4159   QualType cv3T3;
4160   if (isa<CXXConversionDecl>(Function))
4161     cv3T3 = Function->getReturnType();
4162   else
4163     cv3T3 = T1;
4164
4165   ExprValueKind VK = VK_RValue;
4166   if (cv3T3->isLValueReferenceType())
4167     VK = VK_LValue;
4168   else if (const auto *RRef = cv3T3->getAs<RValueReferenceType>())
4169     VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
4170   cv3T3 = cv3T3.getNonLValueExprType(S.Context);
4171
4172   // Add the user-defined conversion step.
4173   bool HadMultipleCandidates = (CandidateSet.size() > 1);
4174   Sequence.AddUserConversionStep(Function, Best->FoundDecl, cv3T3,
4175                                  HadMultipleCandidates);
4176
4177   // Determine whether we'll need to perform derived-to-base adjustments or
4178   // other conversions.
4179   bool NewDerivedToBase = false;
4180   bool NewObjCConversion = false;
4181   bool NewObjCLifetimeConversion = false;
4182   Sema::ReferenceCompareResult NewRefRelationship
4183     = S.CompareReferenceRelationship(DeclLoc, T1, cv3T3,
4184                                      NewDerivedToBase, NewObjCConversion,
4185                                      NewObjCLifetimeConversion);
4186
4187   // Add the final conversion sequence, if necessary.
4188   if (NewRefRelationship == Sema::Ref_Incompatible) {
4189     assert(!isa<CXXConstructorDecl>(Function) &&
4190            "should not have conversion after constructor");
4191
4192     ImplicitConversionSequence ICS;
4193     ICS.setStandard();
4194     ICS.Standard = Best->FinalConversion;
4195     Sequence.AddConversionSequenceStep(ICS, ICS.Standard.getToType(2));
4196
4197     // Every implicit conversion results in a prvalue, except for a glvalue
4198     // derived-to-base conversion, which we handle below.
4199     cv3T3 = ICS.Standard.getToType(2);
4200     VK = VK_RValue;
4201   }
4202
4203   //   If the converted initializer is a prvalue, its type T4 is adjusted to
4204   //   type "cv1 T4" and the temporary materialization conversion is applied.
4205   //
4206   // We adjust the cv-qualifications to match the reference regardless of
4207   // whether we have a prvalue so that the AST records the change. In this
4208   // case, T4 is "cv3 T3".
4209   QualType cv1T4 = S.Context.getQualifiedType(cv3T3, cv1T1.getQualifiers());
4210   if (cv1T4.getQualifiers() != cv3T3.getQualifiers())
4211     Sequence.AddQualificationConversionStep(cv1T4, VK);
4212   Sequence.AddReferenceBindingStep(cv1T4, VK == VK_RValue);
4213   VK = IsLValueRef ? VK_LValue : VK_XValue;
4214
4215   if (NewDerivedToBase)
4216     Sequence.AddDerivedToBaseCastStep(cv1T1, VK);
4217   else if (NewObjCConversion)
4218     Sequence.AddObjCObjectConversionStep(cv1T1);
4219
4220   return OR_Success;
4221 }
4222
4223 static void CheckCXX98CompatAccessibleCopy(Sema &S,
4224                                            const InitializedEntity &Entity,
4225                                            Expr *CurInitExpr);
4226
4227 /// \brief Attempt reference initialization (C++0x [dcl.init.ref])
4228 static void TryReferenceInitialization(Sema &S,
4229                                        const InitializedEntity &Entity,
4230                                        const InitializationKind &Kind,
4231                                        Expr *Initializer,
4232                                        InitializationSequence &Sequence) {
4233   QualType DestType = Entity.getType();
4234   QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
4235   Qualifiers T1Quals;
4236   QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
4237   QualType cv2T2 = Initializer->getType();
4238   Qualifiers T2Quals;
4239   QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
4240
4241   // If the initializer is the address of an overloaded function, try
4242   // to resolve the overloaded function. If all goes well, T2 is the
4243   // type of the resulting function.
4244   if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
4245                                                    T1, Sequence))
4246     return;
4247
4248   // Delegate everything else to a subfunction.
4249   TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
4250                                  T1Quals, cv2T2, T2, T2Quals, Sequence);
4251 }
4252
4253 /// Determine whether an expression is a non-referenceable glvalue (one to
4254 /// which a reference can never bind). Attemting to bind a reference to
4255 /// such a glvalue will always create a temporary.
4256 static bool isNonReferenceableGLValue(Expr *E) {
4257   return E->refersToBitField() || E->refersToVectorElement();
4258 }
4259
4260 /// \brief Reference initialization without resolving overloaded functions.
4261 static void TryReferenceInitializationCore(Sema &S,
4262                                            const InitializedEntity &Entity,
4263                                            const InitializationKind &Kind,
4264                                            Expr *Initializer,
4265                                            QualType cv1T1, QualType T1,
4266                                            Qualifiers T1Quals,
4267                                            QualType cv2T2, QualType T2,
4268                                            Qualifiers T2Quals,
4269                                            InitializationSequence &Sequence) {
4270   QualType DestType = Entity.getType();
4271   SourceLocation DeclLoc = Initializer->getLocStart();
4272   // Compute some basic properties of the types and the initializer.
4273   bool isLValueRef = DestType->isLValueReferenceType();
4274   bool isRValueRef = !isLValueRef;
4275   bool DerivedToBase = false;
4276   bool ObjCConversion = false;
4277   bool ObjCLifetimeConversion = false;
4278   Expr::Classification InitCategory = Initializer->Classify(S.Context);
4279   Sema::ReferenceCompareResult RefRelationship
4280     = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
4281                                      ObjCConversion, ObjCLifetimeConversion);
4282
4283   // C++0x [dcl.init.ref]p5:
4284   //   A reference to type "cv1 T1" is initialized by an expression of type
4285   //   "cv2 T2" as follows:
4286   //
4287   //     - If the reference is an lvalue reference and the initializer
4288   //       expression
4289   // Note the analogous bullet points for rvalue refs to functions. Because
4290   // there are no function rvalues in C++, rvalue refs to functions are treated
4291   // like lvalue refs.
4292   OverloadingResult ConvOvlResult = OR_Success;
4293   bool T1Function = T1->isFunctionType();
4294   if (isLValueRef || T1Function) {
4295     if (InitCategory.isLValue() && !isNonReferenceableGLValue(Initializer) &&
4296         (RefRelationship == Sema::Ref_Compatible ||
4297          (Kind.isCStyleOrFunctionalCast() &&
4298           RefRelationship == Sema::Ref_Related))) {
4299       //   - is an lvalue (but is not a bit-field), and "cv1 T1" is
4300       //     reference-compatible with "cv2 T2," or
4301       if (T1Quals != T2Quals)
4302         // Convert to cv1 T2. This should only add qualifiers unless this is a
4303         // c-style cast. The removal of qualifiers in that case notionally
4304         // happens after the reference binding, but that doesn't matter.
4305         Sequence.AddQualificationConversionStep(
4306             S.Context.getQualifiedType(T2, T1Quals),
4307             Initializer->getValueKind());
4308       if (DerivedToBase)
4309         Sequence.AddDerivedToBaseCastStep(cv1T1, VK_LValue);
4310       else if (ObjCConversion)
4311         Sequence.AddObjCObjectConversionStep(cv1T1);
4312
4313       // We only create a temporary here when binding a reference to a
4314       // bit-field or vector element. Those cases are't supposed to be
4315       // handled by this bullet, but the outcome is the same either way.
4316       Sequence.AddReferenceBindingStep(cv1T1, false);
4317       return;
4318     }
4319
4320     //     - has a class type (i.e., T2 is a class type), where T1 is not
4321     //       reference-related to T2, and can be implicitly converted to an
4322     //       lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
4323     //       with "cv3 T3" (this conversion is selected by enumerating the
4324     //       applicable conversion functions (13.3.1.6) and choosing the best
4325     //       one through overload resolution (13.3)),
4326     // If we have an rvalue ref to function type here, the rhs must be
4327     // an rvalue. DR1287 removed the "implicitly" here.
4328     if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
4329         (isLValueRef || InitCategory.isRValue())) {
4330       ConvOvlResult = TryRefInitWithConversionFunction(
4331           S, Entity, Kind, Initializer, /*AllowRValues*/ isRValueRef,
4332           /*IsLValueRef*/ isLValueRef, Sequence);
4333       if (ConvOvlResult == OR_Success)
4334         return;
4335       if (ConvOvlResult != OR_No_Viable_Function)
4336         Sequence.SetOverloadFailure(
4337             InitializationSequence::FK_ReferenceInitOverloadFailed,
4338             ConvOvlResult);
4339     }
4340   }
4341
4342   //     - Otherwise, the reference shall be an lvalue reference to a
4343   //       non-volatile const type (i.e., cv1 shall be const), or the reference
4344   //       shall be an rvalue reference.
4345   if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
4346     if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4347       Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
4348     else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4349       Sequence.SetOverloadFailure(
4350                         InitializationSequence::FK_ReferenceInitOverloadFailed,
4351                                   ConvOvlResult);
4352     else if (!InitCategory.isLValue())
4353       Sequence.SetFailed(
4354           InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
4355     else {
4356       InitializationSequence::FailureKind FK;
4357       switch (RefRelationship) {
4358       case Sema::Ref_Compatible:
4359         if (Initializer->refersToBitField())
4360           FK = InitializationSequence::
4361               FK_NonConstLValueReferenceBindingToBitfield;
4362         else if (Initializer->refersToVectorElement())
4363           FK = InitializationSequence::
4364               FK_NonConstLValueReferenceBindingToVectorElement;
4365         else
4366           llvm_unreachable("unexpected kind of compatible initializer");
4367         break;
4368       case Sema::Ref_Related:
4369         FK = InitializationSequence::FK_ReferenceInitDropsQualifiers;
4370         break;
4371       case Sema::Ref_Incompatible:
4372         FK = InitializationSequence::
4373             FK_NonConstLValueReferenceBindingToUnrelated;
4374         break;
4375       }
4376       Sequence.SetFailed(FK);
4377     }
4378     return;
4379   }
4380
4381   //    - If the initializer expression
4382   //      - is an
4383   // [<=14] xvalue (but not a bit-field), class prvalue, array prvalue, or
4384   // [1z]   rvalue (but not a bit-field) or
4385   //        function lvalue and "cv1 T1" is reference-compatible with "cv2 T2"
4386   //
4387   // Note: functions are handled above and below rather than here...
4388   if (!T1Function &&
4389       (RefRelationship == Sema::Ref_Compatible ||
4390        (Kind.isCStyleOrFunctionalCast() &&
4391         RefRelationship == Sema::Ref_Related)) &&
4392       ((InitCategory.isXValue() && !isNonReferenceableGLValue(Initializer)) ||
4393        (InitCategory.isPRValue() &&
4394         (S.getLangOpts().CPlusPlus1z || T2->isRecordType() ||
4395          T2->isArrayType())))) {
4396     ExprValueKind ValueKind = InitCategory.isXValue() ? VK_XValue : VK_RValue;
4397     if (InitCategory.isPRValue() && T2->isRecordType()) {
4398       // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
4399       // compiler the freedom to perform a copy here or bind to the
4400       // object, while C++0x requires that we bind directly to the
4401       // object. Hence, we always bind to the object without making an
4402       // extra copy. However, in C++03 requires that we check for the
4403       // presence of a suitable copy constructor:
4404       //
4405       //   The constructor that would be used to make the copy shall
4406       //   be callable whether or not the copy is actually done.
4407       if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
4408         Sequence.AddExtraneousCopyToTemporary(cv2T2);
4409       else if (S.getLangOpts().CPlusPlus11)
4410         CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
4411     }
4412
4413     // C++1z [dcl.init.ref]/5.2.1.2:
4414     //   If the converted initializer is a prvalue, its type T4 is adjusted
4415     //   to type "cv1 T4" and the temporary materialization conversion is
4416     //   applied.
4417     QualType cv1T4 = S.Context.getQualifiedType(cv2T2, T1Quals);
4418     if (T1Quals != T2Quals)
4419       Sequence.AddQualificationConversionStep(cv1T4, ValueKind);
4420     Sequence.AddReferenceBindingStep(cv1T4, ValueKind == VK_RValue);
4421     ValueKind = isLValueRef ? VK_LValue : VK_XValue;
4422
4423     //   In any case, the reference is bound to the resulting glvalue (or to
4424     //   an appropriate base class subobject).
4425     if (DerivedToBase)
4426       Sequence.AddDerivedToBaseCastStep(cv1T1, ValueKind);
4427     else if (ObjCConversion)
4428       Sequence.AddObjCObjectConversionStep(cv1T1);
4429     return;
4430   }
4431
4432   //       - has a class type (i.e., T2 is a class type), where T1 is not
4433   //         reference-related to T2, and can be implicitly converted to an
4434   //         xvalue, class prvalue, or function lvalue of type "cv3 T3",
4435   //         where "cv1 T1" is reference-compatible with "cv3 T3",
4436   //
4437   // DR1287 removes the "implicitly" here.
4438   if (T2->isRecordType()) {
4439     if (RefRelationship == Sema::Ref_Incompatible) {
4440       ConvOvlResult = TryRefInitWithConversionFunction(
4441           S, Entity, Kind, Initializer, /*AllowRValues*/ true,
4442           /*IsLValueRef*/ isLValueRef, Sequence);
4443       if (ConvOvlResult)
4444         Sequence.SetOverloadFailure(
4445             InitializationSequence::FK_ReferenceInitOverloadFailed,
4446             ConvOvlResult);
4447
4448       return;
4449     }
4450
4451     if (RefRelationship == Sema::Ref_Compatible &&
4452         isRValueRef && InitCategory.isLValue()) {
4453       Sequence.SetFailed(
4454         InitializationSequence::FK_RValueReferenceBindingToLValue);
4455       return;
4456     }
4457
4458     Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
4459     return;
4460   }
4461
4462   //      - Otherwise, a temporary of type "cv1 T1" is created and initialized
4463   //        from the initializer expression using the rules for a non-reference
4464   //        copy-initialization (8.5). The reference is then bound to the
4465   //        temporary. [...]
4466
4467   InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
4468
4469   // FIXME: Why do we use an implicit conversion here rather than trying
4470   // copy-initialization?
4471   ImplicitConversionSequence ICS
4472     = S.TryImplicitConversion(Initializer, TempEntity.getType(),
4473                               /*SuppressUserConversions=*/false,
4474                               /*AllowExplicit=*/false,
4475                               /*FIXME:InOverloadResolution=*/false,
4476                               /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4477                               /*AllowObjCWritebackConversion=*/false);
4478
4479   if (ICS.isBad()) {
4480     // FIXME: Use the conversion function set stored in ICS to turn
4481     // this into an overloading ambiguity diagnostic. However, we need
4482     // to keep that set as an OverloadCandidateSet rather than as some
4483     // other kind of set.
4484     if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4485       Sequence.SetOverloadFailure(
4486                         InitializationSequence::FK_ReferenceInitOverloadFailed,
4487                                   ConvOvlResult);
4488     else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4489       Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
4490     else
4491       Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed);
4492     return;
4493   } else {
4494     Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
4495   }
4496
4497   //        [...] If T1 is reference-related to T2, cv1 must be the
4498   //        same cv-qualification as, or greater cv-qualification
4499   //        than, cv2; otherwise, the program is ill-formed.
4500   unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
4501   unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
4502   if (RefRelationship == Sema::Ref_Related &&
4503       (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
4504     Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
4505     return;
4506   }
4507
4508   //   [...] If T1 is reference-related to T2 and the reference is an rvalue
4509   //   reference, the initializer expression shall not be an lvalue.
4510   if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
4511       InitCategory.isLValue()) {
4512     Sequence.SetFailed(
4513                     InitializationSequence::FK_RValueReferenceBindingToLValue);
4514     return;
4515   }
4516
4517   Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
4518 }
4519
4520 /// \brief Attempt character array initialization from a string literal
4521 /// (C++ [dcl.init.string], C99 6.7.8).
4522 static void TryStringLiteralInitialization(Sema &S,
4523                                            const InitializedEntity &Entity,
4524                                            const InitializationKind &Kind,
4525                                            Expr *Initializer,
4526                                        InitializationSequence &Sequence) {
4527   Sequence.AddStringInitStep(Entity.getType());
4528 }
4529
4530 /// \brief Attempt value initialization (C++ [dcl.init]p7).
4531 static void TryValueInitialization(Sema &S,
4532                                    const InitializedEntity &Entity,
4533                                    const InitializationKind &Kind,
4534                                    InitializationSequence &Sequence,
4535                                    InitListExpr *InitList) {
4536   assert((!InitList || InitList->getNumInits() == 0) &&
4537          "Shouldn't use value-init for non-empty init lists");
4538
4539   // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
4540   //
4541   //   To value-initialize an object of type T means:
4542   QualType T = Entity.getType();
4543
4544   //     -- if T is an array type, then each element is value-initialized;
4545   T = S.Context.getBaseElementType(T);
4546
4547   if (const RecordType *RT = T->getAs<RecordType>()) {
4548     if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
4549       bool NeedZeroInitialization = true;
4550       // C++98:
4551       // -- if T is a class type (clause 9) with a user-declared constructor
4552       //    (12.1), then the default constructor for T is called (and the
4553       //    initialization is ill-formed if T has no accessible default
4554       //    constructor);
4555       // C++11:
4556       // -- if T is a class type (clause 9) with either no default constructor
4557       //    (12.1 [class.ctor]) or a default constructor that is user-provided
4558       //    or deleted, then the object is default-initialized;
4559       //
4560       // Note that the C++11 rule is the same as the C++98 rule if there are no
4561       // defaulted or deleted constructors, so we just use it unconditionally.
4562       CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
4563       if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
4564         NeedZeroInitialization = false;
4565
4566       // -- if T is a (possibly cv-qualified) non-union class type without a
4567       //    user-provided or deleted default constructor, then the object is
4568       //    zero-initialized and, if T has a non-trivial default constructor,
4569       //    default-initialized;
4570       // The 'non-union' here was removed by DR1502. The 'non-trivial default
4571       // constructor' part was removed by DR1507.
4572       if (NeedZeroInitialization)
4573         Sequence.AddZeroInitializationStep(Entity.getType());
4574
4575       // C++03:
4576       // -- if T is a non-union class type without a user-declared constructor,
4577       //    then every non-static data member and base class component of T is
4578       //    value-initialized;
4579       // [...] A program that calls for [...] value-initialization of an
4580       // entity of reference type is ill-formed.
4581       //
4582       // C++11 doesn't need this handling, because value-initialization does not
4583       // occur recursively there, and the implicit default constructor is
4584       // defined as deleted in the problematic cases.
4585       if (!S.getLangOpts().CPlusPlus11 &&
4586           ClassDecl->hasUninitializedReferenceMember()) {
4587         Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForReference);
4588         return;
4589       }
4590
4591       // If this is list-value-initialization, pass the empty init list on when
4592       // building the constructor call. This affects the semantics of a few
4593       // things (such as whether an explicit default constructor can be called).
4594       Expr *InitListAsExpr = InitList;
4595       MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
4596       bool InitListSyntax = InitList;
4597
4598       // FIXME: Instead of creating a CXXConstructExpr of array type here,
4599       // wrap a class-typed CXXConstructExpr in an ArrayInitLoopExpr.
4600       return TryConstructorInitialization(
4601           S, Entity, Kind, Args, T, Entity.getType(), Sequence, InitListSyntax);
4602     }
4603   }
4604
4605   Sequence.AddZeroInitializationStep(Entity.getType());
4606 }
4607
4608 /// \brief Attempt default initialization (C++ [dcl.init]p6).
4609 static void TryDefaultInitialization(Sema &S,
4610                                      const InitializedEntity &Entity,
4611                                      const InitializationKind &Kind,
4612                                      InitializationSequence &Sequence) {
4613   assert(Kind.getKind() == InitializationKind::IK_Default);
4614
4615   // C++ [dcl.init]p6:
4616   //   To default-initialize an object of type T means:
4617   //     - if T is an array type, each element is default-initialized;
4618   QualType DestType = S.Context.getBaseElementType(Entity.getType());
4619
4620   //     - if T is a (possibly cv-qualified) class type (Clause 9), the default
4621   //       constructor for T is called (and the initialization is ill-formed if
4622   //       T has no accessible default constructor);
4623   if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
4624     TryConstructorInitialization(S, Entity, Kind, None, DestType,
4625                                  Entity.getType(), Sequence);
4626     return;
4627   }
4628
4629   //     - otherwise, no initialization is performed.
4630
4631   //   If a program calls for the default initialization of an object of
4632   //   a const-qualified type T, T shall be a class type with a user-provided
4633   //   default constructor.
4634   if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
4635     if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
4636       Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
4637     return;
4638   }
4639
4640   // If the destination type has a lifetime property, zero-initialize it.
4641   if (DestType.getQualifiers().hasObjCLifetime()) {
4642     Sequence.AddZeroInitializationStep(Entity.getType());
4643     return;
4644   }
4645 }
4646
4647 /// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
4648 /// which enumerates all conversion functions and performs overload resolution
4649 /// to select the best.
4650 static void TryUserDefinedConversion(Sema &S,
4651                                      QualType DestType,
4652                                      const InitializationKind &Kind,
4653                                      Expr *Initializer,
4654                                      InitializationSequence &Sequence,
4655                                      bool TopLevelOfInitList) {
4656   assert(!DestType->isReferenceType() && "References are handled elsewhere");
4657   QualType SourceType = Initializer->getType();
4658   assert((DestType->isRecordType() || SourceType->isRecordType()) &&
4659          "Must have a class type to perform a user-defined conversion");
4660
4661   // Build the candidate set directly in the initialization sequence
4662   // structure, so that it will persist if we fail.
4663   OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4664   CandidateSet.clear();
4665
4666   // Determine whether we are allowed to call explicit constructors or
4667   // explicit conversion operators.
4668   bool AllowExplicit = Kind.AllowExplicit();
4669
4670   if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4671     // The type we're converting to is a class type. Enumerate its constructors
4672     // to see if there is a suitable conversion.
4673     CXXRecordDecl *DestRecordDecl
4674       = cast<CXXRecordDecl>(DestRecordType->getDecl());
4675
4676     // Try to complete the type we're converting to.
4677     if (S.isCompleteType(Kind.getLocation(), DestType)) {
4678       DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
4679       // The container holding the constructors can under certain conditions
4680       // be changed while iterating. To be safe we copy the lookup results
4681       // to a new container.
4682       SmallVector<NamedDecl*, 8> CopyOfCon(R.begin(), R.end());
4683       for (SmallVectorImpl<NamedDecl *>::iterator
4684              Con = CopyOfCon.begin(), ConEnd = CopyOfCon.end();
4685            Con != ConEnd; ++Con) {
4686         NamedDecl *D = *Con;
4687         auto Info = getConstructorInfo(D);
4688         if (!Info.Constructor)
4689           continue;
4690
4691         if (!Info.Constructor->isInvalidDecl() &&
4692             Info.Constructor->isConvertingConstructor(AllowExplicit)) {
4693           if (Info.ConstructorTmpl)
4694             S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
4695                                            /*ExplicitArgs*/ nullptr,
4696                                            Initializer, CandidateSet,
4697                                            /*SuppressUserConversions=*/true);
4698           else
4699             S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
4700                                    Initializer, CandidateSet,
4701                                    /*SuppressUserConversions=*/true);
4702         }
4703       }
4704     }
4705   }
4706
4707   SourceLocation DeclLoc = Initializer->getLocStart();
4708
4709   if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
4710     // The type we're converting from is a class type, enumerate its conversion
4711     // functions.
4712
4713     // We can only enumerate the conversion functions for a complete type; if
4714     // the type isn't complete, simply skip this step.
4715     if (S.isCompleteType(DeclLoc, SourceType)) {
4716       CXXRecordDecl *SourceRecordDecl
4717         = cast<CXXRecordDecl>(SourceRecordType->getDecl());
4718
4719       const auto &Conversions =
4720           SourceRecordDecl->getVisibleConversionFunctions();
4721       for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4722         NamedDecl *D = *I;
4723         CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4724         if (isa<UsingShadowDecl>(D))
4725           D = cast<UsingShadowDecl>(D)->getTargetDecl();
4726
4727         FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4728         CXXConversionDecl *Conv;
4729         if (ConvTemplate)
4730           Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4731         else
4732           Conv = cast<CXXConversionDecl>(D);
4733
4734         if (AllowExplicit || !Conv->isExplicit()) {
4735           if (ConvTemplate)
4736             S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4737                                              ActingDC, Initializer, DestType,
4738                                              CandidateSet, AllowExplicit);
4739           else
4740             S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4741                                      Initializer, DestType, CandidateSet,
4742                                      AllowExplicit);
4743         }
4744       }
4745     }
4746   }
4747
4748   // Perform overload resolution. If it fails, return the failed result.
4749   OverloadCandidateSet::iterator Best;
4750   if (OverloadingResult Result
4751         = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
4752     Sequence.SetOverloadFailure(
4753                         InitializationSequence::FK_UserConversionOverloadFailed,
4754                                 Result);
4755     return;
4756   }
4757
4758   FunctionDecl *Function = Best->Function;
4759   Function->setReferenced();
4760   bool HadMultipleCandidates = (CandidateSet.size() > 1);
4761
4762   if (isa<CXXConstructorDecl>(Function)) {
4763     // Add the user-defined conversion step. Any cv-qualification conversion is
4764     // subsumed by the initialization. Per DR5, the created temporary is of the
4765     // cv-unqualified type of the destination.
4766     Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4767                                    DestType.getUnqualifiedType(),
4768                                    HadMultipleCandidates);
4769
4770     // C++14 and before:
4771     //   - if the function is a constructor, the call initializes a temporary
4772     //     of the cv-unqualified version of the destination type. The [...]
4773     //     temporary [...] is then used to direct-initialize, according to the
4774     //     rules above, the object that is the destination of the
4775     //     copy-initialization.
4776     // Note that this just performs a simple object copy from the temporary.
4777     //
4778     // C++1z:
4779     //   - if the function is a constructor, the call is a prvalue of the
4780     //     cv-unqualified version of the destination type whose return object
4781     //     is initialized by the constructor. The call is used to
4782     //     direct-initialize, according to the rules above, the object that
4783     //     is the destination of the copy-initialization.
4784     // Therefore we need to do nothing further.
4785     //
4786     // FIXME: Mark this copy as extraneous.
4787     if (!S.getLangOpts().CPlusPlus1z)
4788       Sequence.AddFinalCopy(DestType);
4789     else if (DestType.hasQualifiers())
4790       Sequence.AddQualificationConversionStep(DestType, VK_RValue);
4791     return;
4792   }
4793
4794   // Add the user-defined conversion step that calls the conversion function.
4795   QualType ConvType = Function->getCallResultType();
4796   Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
4797                                  HadMultipleCandidates);
4798
4799   if (ConvType->getAs<RecordType>()) {
4800     //   The call is used to direct-initialize [...] the object that is the
4801     //   destination of the copy-initialization.
4802     //
4803     // In C++1z, this does not call a constructor if we enter /17.6.1:
4804     //   - If the initializer expression is a prvalue and the cv-unqualified
4805     //     version of the source type is the same as the class of the
4806     //     destination [... do not make an extra copy]
4807     //
4808     // FIXME: Mark this copy as extraneous.
4809     if (!S.getLangOpts().CPlusPlus1z ||
4810         Function->getReturnType()->isReferenceType() ||
4811         !S.Context.hasSameUnqualifiedType(ConvType, DestType))
4812       Sequence.AddFinalCopy(DestType);
4813     else if (!S.Context.hasSameType(ConvType, DestType))
4814       Sequence.AddQualificationConversionStep(DestType, VK_RValue);
4815     return;
4816   }
4817
4818   // If the conversion following the call to the conversion function
4819   // is interesting, add it as a separate step.
4820   if (Best->FinalConversion.First || Best->FinalConversion.Second ||
4821       Best->FinalConversion.Third) {
4822     ImplicitConversionSequence ICS;
4823     ICS.setStandard();
4824     ICS.Standard = Best->FinalConversion;
4825     Sequence.AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
4826   }
4827 }
4828
4829 /// An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>,
4830 /// a function with a pointer return type contains a 'return false;' statement.
4831 /// In C++11, 'false' is not a null pointer, so this breaks the build of any
4832 /// code using that header.
4833 ///
4834 /// Work around this by treating 'return false;' as zero-initializing the result
4835 /// if it's used in a pointer-returning function in a system header.
4836 static bool isLibstdcxxPointerReturnFalseHack(Sema &S,
4837                                               const InitializedEntity &Entity,
4838                                               const Expr *Init) {
4839   return S.getLangOpts().CPlusPlus11 &&
4840          Entity.getKind() == InitializedEntity::EK_Result &&
4841          Entity.getType()->isPointerType() &&
4842          isa<CXXBoolLiteralExpr>(Init) &&
4843          !cast<CXXBoolLiteralExpr>(Init)->getValue() &&
4844          S.getSourceManager().isInSystemHeader(Init->getExprLoc());
4845 }
4846
4847 /// The non-zero enum values here are indexes into diagnostic alternatives.
4848 enum InvalidICRKind { IIK_okay, IIK_nonlocal, IIK_nonscalar };
4849
4850 /// Determines whether this expression is an acceptable ICR source.
4851 static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e,
4852                                          bool isAddressOf, bool &isWeakAccess) {
4853   // Skip parens.
4854   e = e->IgnoreParens();
4855
4856   // Skip address-of nodes.
4857   if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
4858     if (op->getOpcode() == UO_AddrOf)
4859       return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
4860                                 isWeakAccess);
4861
4862   // Skip certain casts.
4863   } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
4864     switch (ce->getCastKind()) {
4865     case CK_Dependent:
4866     case CK_BitCast:
4867     case CK_LValueBitCast:
4868     case CK_NoOp:
4869       return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
4870
4871     case CK_ArrayToPointerDecay:
4872       return IIK_nonscalar;
4873
4874     case CK_NullToPointer:
4875       return IIK_okay;
4876
4877     default:
4878       break;
4879     }
4880
4881   // If we have a declaration reference, it had better be a local variable.
4882   } else if (isa<DeclRefExpr>(e)) {
4883     // set isWeakAccess to true, to mean that there will be an implicit
4884     // load which requires a cleanup.
4885     if (e->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
4886       isWeakAccess = true;
4887
4888     if (!isAddressOf) return IIK_nonlocal;
4889
4890     VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
4891     if (!var) return IIK_nonlocal;
4892
4893     return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
4894
4895   // If we have a conditional operator, check both sides.
4896   } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
4897     if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
4898                                                 isWeakAccess))
4899       return iik;
4900
4901     return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
4902
4903   // These are never scalar.
4904   } else if (isa<ArraySubscriptExpr>(e)) {
4905     return IIK_nonscalar;
4906
4907   // Otherwise, it needs to be a null pointer constant.
4908   } else {
4909     return (e->isNullPointerConstant(C, Expr::NPC_ValueDependentIsNull)
4910             ? IIK_okay : IIK_nonlocal);
4911   }
4912
4913   return IIK_nonlocal;
4914 }
4915
4916 /// Check whether the given expression is a valid operand for an
4917 /// indirect copy/restore.
4918 static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {
4919   assert(src->isRValue());
4920   bool isWeakAccess = false;
4921   InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
4922   // If isWeakAccess to true, there will be an implicit
4923   // load which requires a cleanup.
4924   if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
4925     S.Cleanup.setExprNeedsCleanups(true);
4926
4927   if (iik == IIK_okay) return;
4928
4929   S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
4930     << ((unsigned) iik - 1)  // shift index into diagnostic explanations
4931     << src->getSourceRange();
4932 }
4933
4934 /// \brief Determine whether we have compatible array types for the
4935 /// purposes of GNU by-copy array initialization.
4936 static bool hasCompatibleArrayTypes(ASTContext &Context, const ArrayType *Dest,
4937                                     const ArrayType *Source) {
4938   // If the source and destination array types are equivalent, we're
4939   // done.
4940   if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
4941     return true;
4942
4943   // Make sure that the element types are the same.
4944   if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
4945     return false;
4946
4947   // The only mismatch we allow is when the destination is an
4948   // incomplete array type and the source is a constant array type.
4949   return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
4950 }
4951
4952 static bool tryObjCWritebackConversion(Sema &S,
4953                                        InitializationSequence &Sequence,
4954                                        const InitializedEntity &Entity,
4955                                        Expr *Initializer) {
4956   bool ArrayDecay = false;
4957   QualType ArgType = Initializer->getType();
4958   QualType ArgPointee;
4959   if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
4960     ArrayDecay = true;
4961     ArgPointee = ArgArrayType->getElementType();
4962     ArgType = S.Context.getPointerType(ArgPointee);
4963   }
4964
4965   // Handle write-back conversion.
4966   QualType ConvertedArgType;
4967   if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
4968                                    ConvertedArgType))
4969     return false;
4970
4971   // We should copy unless we're passing to an argument explicitly
4972   // marked 'out'.
4973   bool ShouldCopy = true;
4974   if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4975     ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4976
4977   // Do we need an lvalue conversion?
4978   if (ArrayDecay || Initializer->isGLValue()) {
4979     ImplicitConversionSequence ICS;
4980     ICS.setStandard();
4981     ICS.Standard.setAsIdentityConversion();
4982
4983     QualType ResultType;
4984     if (ArrayDecay) {
4985       ICS.Standard.First = ICK_Array_To_Pointer;
4986       ResultType = S.Context.getPointerType(ArgPointee);
4987     } else {
4988       ICS.Standard.First = ICK_Lvalue_To_Rvalue;
4989       ResultType = Initializer->getType().getNonLValueExprType(S.Context);
4990     }
4991
4992     Sequence.AddConversionSequenceStep(ICS, ResultType);
4993   }
4994
4995   Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
4996   return true;
4997 }
4998
4999 static bool TryOCLSamplerInitialization(Sema &S,
5000                                         InitializationSequence &Sequence,
5001                                         QualType DestType,
5002                                         Expr *Initializer) {
5003   if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
5004       (!Initializer->isIntegerConstantExpr(S.Context) &&
5005       !Initializer->getType()->isSamplerT()))
5006     return false;
5007
5008   Sequence.AddOCLSamplerInitStep(DestType);
5009   return true;
5010 }
5011
5012 //
5013 // OpenCL 1.2 spec, s6.12.10
5014 //
5015 // The event argument can also be used to associate the
5016 // async_work_group_copy with a previous async copy allowing
5017 // an event to be shared by multiple async copies; otherwise
5018 // event should be zero.
5019 //
5020 static bool TryOCLZeroEventInitialization(Sema &S,
5021                                           InitializationSequence &Sequence,
5022                                           QualType DestType,
5023                                           Expr *Initializer) {
5024   if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
5025       !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
5026       (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
5027     return false;
5028
5029   Sequence.AddOCLZeroEventStep(DestType);
5030   return true;
5031 }
5032
5033 static bool TryOCLZeroQueueInitialization(Sema &S,
5034                                           InitializationSequence &Sequence,
5035                                           QualType DestType,
5036                                           Expr *Initializer) {
5037   if (!S.getLangOpts().OpenCL || S.getLangOpts().OpenCLVersion < 200 ||
5038       !DestType->isQueueT() ||
5039       !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
5040       (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
5041     return false;
5042
5043   Sequence.AddOCLZeroQueueStep(DestType);
5044   return true;
5045 }
5046
5047 InitializationSequence::InitializationSequence(Sema &S,
5048                                                const InitializedEntity &Entity,
5049                                                const InitializationKind &Kind,
5050                                                MultiExprArg Args,
5051                                                bool TopLevelOfInitList,
5052                                                bool TreatUnavailableAsInvalid)
5053     : FailedCandidateSet(Kind.getLocation(), OverloadCandidateSet::CSK_Normal) {
5054   InitializeFrom(S, Entity, Kind, Args, TopLevelOfInitList,
5055                  TreatUnavailableAsInvalid);
5056 }
5057
5058 /// Tries to get a FunctionDecl out of `E`. If it succeeds and we can take the
5059 /// address of that function, this returns true. Otherwise, it returns false.
5060 static bool isExprAnUnaddressableFunction(Sema &S, const Expr *E) {
5061   auto *DRE = dyn_cast<DeclRefExpr>(E);
5062   if (!DRE || !isa<FunctionDecl>(DRE->getDecl()))
5063     return false;
5064
5065   return !S.checkAddressOfFunctionIsAvailable(
5066       cast<FunctionDecl>(DRE->getDecl()));
5067 }
5068
5069 /// Determine whether we can perform an elementwise array copy for this kind
5070 /// of entity.
5071 static bool canPerformArrayCopy(const InitializedEntity &Entity) {
5072   switch (Entity.getKind()) {
5073   case InitializedEntity::EK_LambdaCapture:
5074     // C++ [expr.prim.lambda]p24:
5075     //   For array members, the array elements are direct-initialized in
5076     //   increasing subscript order.
5077     return true;
5078
5079   case InitializedEntity::EK_Variable:
5080     // C++ [dcl.decomp]p1:
5081     //   [...] each element is copy-initialized or direct-initialized from the
5082     //   corresponding element of the assignment-expression [...]
5083     return isa<DecompositionDecl>(Entity.getDecl());
5084
5085   case InitializedEntity::EK_Member:
5086     // C++ [class.copy.ctor]p14:
5087     //   - if the member is an array, each element is direct-initialized with
5088     //     the corresponding subobject of x
5089     return Entity.isImplicitMemberInitializer();
5090
5091   case InitializedEntity::EK_ArrayElement:
5092     // All the above cases are intended to apply recursively, even though none
5093     // of them actually say that.
5094     if (auto *E = Entity.getParent())
5095       return canPerformArrayCopy(*E);
5096     break;
5097
5098   default:
5099     break;
5100   }
5101
5102   return false;
5103 }
5104
5105 void InitializationSequence::InitializeFrom(Sema &S,
5106                                             const InitializedEntity &Entity,
5107                                             const InitializationKind &Kind,
5108                                             MultiExprArg Args,
5109                                             bool TopLevelOfInitList,
5110                                             bool TreatUnavailableAsInvalid) {
5111   ASTContext &Context = S.Context;
5112
5113   // Eliminate non-overload placeholder types in the arguments.  We
5114   // need to do this before checking whether types are dependent
5115   // because lowering a pseudo-object expression might well give us
5116   // something of dependent type.
5117   for (unsigned I = 0, E = Args.size(); I != E; ++I)
5118     if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
5119       // FIXME: should we be doing this here?
5120       ExprResult result = S.CheckPlaceholderExpr(Args[I]);
5121       if (result.isInvalid()) {
5122         SetFailed(FK_PlaceholderType);
5123         return;
5124       }
5125       Args[I] = result.get();
5126     }
5127
5128   // C++0x [dcl.init]p16:
5129   //   The semantics of initializers are as follows. The destination type is
5130   //   the type of the object or reference being initialized and the source
5131   //   type is the type of the initializer expression. The source type is not
5132   //   defined when the initializer is a braced-init-list or when it is a
5133   //   parenthesized list of expressions.
5134   QualType DestType = Entity.getType();
5135
5136   if (DestType->isDependentType() ||
5137       Expr::hasAnyTypeDependentArguments(Args)) {
5138     SequenceKind = DependentSequence;
5139     return;
5140   }
5141
5142   // Almost everything is a normal sequence.
5143   setSequenceKind(NormalSequence);
5144
5145   QualType SourceType;
5146   Expr *Initializer = nullptr;
5147   if (Args.size() == 1) {
5148     Initializer = Args[0];
5149     if (S.getLangOpts().ObjC1) {
5150       if (S.CheckObjCBridgeRelatedConversions(Initializer->getLocStart(),
5151                                               DestType, Initializer->getType(),
5152                                               Initializer) ||
5153           S.ConversionToObjCStringLiteralCheck(DestType, Initializer))
5154         Args[0] = Initializer;
5155     }
5156     if (!isa<InitListExpr>(Initializer))
5157       SourceType = Initializer->getType();
5158   }
5159
5160   //     - If the initializer is a (non-parenthesized) braced-init-list, the
5161   //       object is list-initialized (8.5.4).
5162   if (Kind.getKind() != InitializationKind::IK_Direct) {
5163     if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
5164       TryListInitialization(S, Entity, Kind, InitList, *this,
5165                             TreatUnavailableAsInvalid);
5166       return;
5167     }
5168   }
5169
5170   //     - If the destination type is a reference type, see 8.5.3.
5171   if (DestType->isReferenceType()) {
5172     // C++0x [dcl.init.ref]p1:
5173     //   A variable declared to be a T& or T&&, that is, "reference to type T"
5174     //   (8.3.2), shall be initialized by an object, or function, of type T or
5175     //   by an object that can be converted into a T.
5176     // (Therefore, multiple arguments are not permitted.)
5177     if (Args.size() != 1)
5178       SetFailed(FK_TooManyInitsForReference);
5179     else
5180       TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
5181     return;
5182   }
5183
5184   //     - If the initializer is (), the object is value-initialized.
5185   if (Kind.getKind() == InitializationKind::IK_Value ||
5186       (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
5187     TryValueInitialization(S, Entity, Kind, *this);
5188     return;
5189   }
5190
5191   // Handle default initialization.
5192   if (Kind.getKind() == InitializationKind::IK_Default) {
5193     TryDefaultInitialization(S, Entity, Kind, *this);
5194     return;
5195   }
5196
5197   //     - If the destination type is an array of characters, an array of
5198   //       char16_t, an array of char32_t, or an array of wchar_t, and the
5199   //       initializer is a string literal, see 8.5.2.
5200   //     - Otherwise, if the destination type is an array, the program is
5201   //       ill-formed.
5202   if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
5203     if (Initializer && isa<VariableArrayType>(DestAT)) {
5204       SetFailed(FK_VariableLengthArrayHasInitializer);
5205       return;
5206     }
5207
5208     if (Initializer) {
5209       switch (IsStringInit(Initializer, DestAT, Context)) {
5210       case SIF_None:
5211         TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
5212         return;
5213       case SIF_NarrowStringIntoWideChar:
5214         SetFailed(FK_NarrowStringIntoWideCharArray);
5215         return;
5216       case SIF_WideStringIntoChar:
5217         SetFailed(FK_WideStringIntoCharArray);
5218         return;
5219       case SIF_IncompatWideStringIntoWideChar:
5220         SetFailed(FK_IncompatWideStringIntoWideChar);
5221         return;
5222       case SIF_Other:
5223         break;
5224       }
5225     }
5226
5227     // Some kinds of initialization permit an array to be initialized from
5228     // another array of the same type, and perform elementwise initialization.
5229     if (Initializer && isa<ConstantArrayType>(DestAT) &&
5230         S.Context.hasSameUnqualifiedType(Initializer->getType(),
5231                                          Entity.getType()) &&
5232         canPerformArrayCopy(Entity)) {
5233       // If source is a prvalue, use it directly.
5234       if (Initializer->getValueKind() == VK_RValue) {
5235         AddArrayInitStep(DestType, /*IsGNUExtension*/false);
5236         return;
5237       }
5238
5239       // Emit element-at-a-time copy loop.
5240       InitializedEntity Element =
5241           InitializedEntity::InitializeElement(S.Context, 0, Entity);
5242       QualType InitEltT =
5243           Context.getAsArrayType(Initializer->getType())->getElementType();
5244       OpaqueValueExpr OVE(Initializer->getExprLoc(), InitEltT,
5245                           Initializer->getValueKind(),
5246                           Initializer->getObjectKind());
5247       Expr *OVEAsExpr = &OVE;
5248       InitializeFrom(S, Element, Kind, OVEAsExpr, TopLevelOfInitList,
5249                      TreatUnavailableAsInvalid);
5250       if (!Failed())
5251         AddArrayInitLoopStep(Entity.getType(), InitEltT);
5252       return;
5253     }
5254
5255     // Note: as an GNU C extension, we allow initialization of an
5256     // array from a compound literal that creates an array of the same
5257     // type, so long as the initializer has no side effects.
5258     if (!S.getLangOpts().CPlusPlus && Initializer &&
5259         isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
5260         Initializer->getType()->isArrayType()) {
5261       const ArrayType *SourceAT
5262         = Context.getAsArrayType(Initializer->getType());
5263       if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
5264         SetFailed(FK_ArrayTypeMismatch);
5265       else if (Initializer->HasSideEffects(S.Context))
5266         SetFailed(FK_NonConstantArrayInit);
5267       else {
5268         AddArrayInitStep(DestType, /*IsGNUExtension*/true);
5269       }
5270     }
5271     // Note: as a GNU C++ extension, we allow list-initialization of a
5272     // class member of array type from a parenthesized initializer list.
5273     else if (S.getLangOpts().CPlusPlus &&
5274              Entity.getKind() == InitializedEntity::EK_Member &&
5275              Initializer && isa<InitListExpr>(Initializer)) {
5276       TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
5277                             *this, TreatUnavailableAsInvalid);
5278       AddParenthesizedArrayInitStep(DestType);
5279     } else if (DestAT->getElementType()->isCharType())
5280       SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
5281     else if (IsWideCharCompatible(DestAT->getElementType(), Context))
5282       SetFailed(FK_ArrayNeedsInitListOrWideStringLiteral);
5283     else
5284       SetFailed(FK_ArrayNeedsInitList);
5285
5286     return;
5287   }
5288
5289   // Determine whether we should consider writeback conversions for
5290   // Objective-C ARC.
5291   bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
5292          Entity.isParameterKind();
5293
5294   // We're at the end of the line for C: it's either a write-back conversion
5295   // or it's a C assignment. There's no need to check anything else.
5296   if (!S.getLangOpts().CPlusPlus) {
5297     // If allowed, check whether this is an Objective-C writeback conversion.
5298     if (allowObjCWritebackConversion &&
5299         tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
5300       return;
5301     }
5302
5303     if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
5304       return;
5305
5306     if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
5307       return;
5308
5309     if (TryOCLZeroQueueInitialization(S, *this, DestType, Initializer))
5310        return;
5311
5312     // Handle initialization in C
5313     AddCAssignmentStep(DestType);
5314     MaybeProduceObjCObject(S, *this, Entity);
5315     return;
5316   }
5317
5318   assert(S.getLangOpts().CPlusPlus);
5319
5320   //     - If the destination type is a (possibly cv-qualified) class type:
5321   if (DestType->isRecordType()) {
5322     //     - If the initialization is direct-initialization, or if it is
5323     //       copy-initialization where the cv-unqualified version of the
5324     //       source type is the same class as, or a derived class of, the
5325     //       class of the destination, constructors are considered. [...]
5326     if (Kind.getKind() == InitializationKind::IK_Direct ||
5327         (Kind.getKind() == InitializationKind::IK_Copy &&
5328          (Context.hasSameUnqualifiedType(SourceType, DestType) ||
5329           S.IsDerivedFrom(Initializer->getLocStart(), SourceType, DestType))))
5330       TryConstructorInitialization(S, Entity, Kind, Args,
5331                                    DestType, DestType, *this);
5332     //     - Otherwise (i.e., for the remaining copy-initialization cases),
5333     //       user-defined conversion sequences that can convert from the source
5334     //       type to the destination type or (when a conversion function is
5335     //       used) to a derived class thereof are enumerated as described in
5336     //       13.3.1.4, and the best one is chosen through overload resolution
5337     //       (13.3).
5338     else
5339       TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5340                                TopLevelOfInitList);
5341     return;
5342   }
5343
5344   if (Args.size() > 1) {
5345     SetFailed(FK_TooManyInitsForScalar);
5346     return;
5347   }
5348   assert(Args.size() == 1 && "Zero-argument case handled above");
5349
5350   //    - Otherwise, if the source type is a (possibly cv-qualified) class
5351   //      type, conversion functions are considered.
5352   if (!SourceType.isNull() && SourceType->isRecordType()) {
5353     // For a conversion to _Atomic(T) from either T or a class type derived
5354     // from T, initialize the T object then convert to _Atomic type.
5355     bool NeedAtomicConversion = false;
5356     if (const AtomicType *Atomic = DestType->getAs<AtomicType>()) {
5357       if (Context.hasSameUnqualifiedType(SourceType, Atomic->getValueType()) ||
5358           S.IsDerivedFrom(Initializer->getLocStart(), SourceType,
5359                           Atomic->getValueType())) {
5360         DestType = Atomic->getValueType();
5361         NeedAtomicConversion = true;
5362       }
5363     }
5364
5365     TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5366                              TopLevelOfInitList);
5367     MaybeProduceObjCObject(S, *this, Entity);
5368     if (!Failed() && NeedAtomicConversion)
5369       AddAtomicConversionStep(Entity.getType());
5370     return;
5371   }
5372
5373   //    - Otherwise, the initial value of the object being initialized is the
5374   //      (possibly converted) value of the initializer expression. Standard
5375   //      conversions (Clause 4) will be used, if necessary, to convert the
5376   //      initializer expression to the cv-unqualified version of the
5377   //      destination type; no user-defined conversions are considered.
5378
5379   ImplicitConversionSequence ICS
5380     = S.TryImplicitConversion(Initializer, DestType,
5381                               /*SuppressUserConversions*/true,
5382                               /*AllowExplicitConversions*/ false,
5383                               /*InOverloadResolution*/ false,
5384                               /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
5385                               allowObjCWritebackConversion);
5386
5387   if (ICS.isStandard() &&
5388       ICS.Standard.Second == ICK_Writeback_Conversion) {
5389     // Objective-C ARC writeback conversion.
5390
5391     // We should copy unless we're passing to an argument explicitly
5392     // marked 'out'.
5393     bool ShouldCopy = true;
5394     if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
5395       ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
5396
5397     // If there was an lvalue adjustment, add it as a separate conversion.
5398     if (ICS.Standard.First == ICK_Array_To_Pointer ||
5399         ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
5400       ImplicitConversionSequence LvalueICS;
5401       LvalueICS.setStandard();
5402       LvalueICS.Standard.setAsIdentityConversion();
5403       LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0));
5404       LvalueICS.Standard.First = ICS.Standard.First;
5405       AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0));
5406     }
5407
5408     AddPassByIndirectCopyRestoreStep(DestType, ShouldCopy);
5409   } else if (ICS.isBad()) {
5410     DeclAccessPair dap;
5411     if (isLibstdcxxPointerReturnFalseHack(S, Entity, Initializer)) {
5412       AddZeroInitializationStep(Entity.getType());
5413     } else if (Initializer->getType() == Context.OverloadTy &&
5414                !S.ResolveAddressOfOverloadedFunction(Initializer, DestType,
5415                                                      false, dap))
5416       SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
5417     else if (Initializer->getType()->isFunctionType() &&
5418              isExprAnUnaddressableFunction(S, Initializer))
5419       SetFailed(InitializationSequence::FK_AddressOfUnaddressableFunction);
5420     else
5421       SetFailed(InitializationSequence::FK_ConversionFailed);
5422   } else {
5423     AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
5424
5425     MaybeProduceObjCObject(S, *this, Entity);
5426   }
5427 }
5428
5429 InitializationSequence::~InitializationSequence() {
5430   for (auto &S : Steps)
5431     S.Destroy();
5432 }
5433
5434 //===----------------------------------------------------------------------===//
5435 // Perform initialization
5436 //===----------------------------------------------------------------------===//
5437 static Sema::AssignmentAction
5438 getAssignmentAction(const InitializedEntity &Entity, bool Diagnose = false) {
5439   switch(Entity.getKind()) {
5440   case InitializedEntity::EK_Variable:
5441   case InitializedEntity::EK_New:
5442   case InitializedEntity::EK_Exception:
5443   case InitializedEntity::EK_Base:
5444   case InitializedEntity::EK_Delegating:
5445     return Sema::AA_Initializing;
5446
5447   case InitializedEntity::EK_Parameter:
5448     if (Entity.getDecl() &&
5449         isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
5450       return Sema::AA_Sending;
5451
5452     return Sema::AA_Passing;
5453
5454   case InitializedEntity::EK_Parameter_CF_Audited:
5455     if (Entity.getDecl() &&
5456       isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
5457       return Sema::AA_Sending;
5458
5459     return !Diagnose ? Sema::AA_Passing : Sema::AA_Passing_CFAudited;
5460
5461   case InitializedEntity::EK_Result:
5462     return Sema::AA_Returning;
5463
5464   case InitializedEntity::EK_Temporary:
5465   case InitializedEntity::EK_RelatedResult:
5466     // FIXME: Can we tell apart casting vs. converting?
5467     return Sema::AA_Casting;
5468
5469   case InitializedEntity::EK_Member:
5470   case InitializedEntity::EK_Binding:
5471   case InitializedEntity::EK_ArrayElement:
5472   case InitializedEntity::EK_VectorElement:
5473   case InitializedEntity::EK_ComplexElement:
5474   case InitializedEntity::EK_BlockElement:
5475   case InitializedEntity::EK_LambdaCapture:
5476   case InitializedEntity::EK_CompoundLiteralInit:
5477     return Sema::AA_Initializing;
5478   }
5479
5480   llvm_unreachable("Invalid EntityKind!");
5481 }
5482
5483 /// \brief Whether we should bind a created object as a temporary when
5484 /// initializing the given entity.
5485 static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
5486   switch (Entity.getKind()) {
5487   case InitializedEntity::EK_ArrayElement:
5488   case InitializedEntity::EK_Member:
5489   case InitializedEntity::EK_Result:
5490   case InitializedEntity::EK_New:
5491   case InitializedEntity::EK_Variable:
5492   case InitializedEntity::EK_Base:
5493   case InitializedEntity::EK_Delegating:
5494   case InitializedEntity::EK_VectorElement:
5495   case InitializedEntity::EK_ComplexElement:
5496   case InitializedEntity::EK_Exception:
5497   case InitializedEntity::EK_BlockElement:
5498   case InitializedEntity::EK_LambdaCapture:
5499   case InitializedEntity::EK_CompoundLiteralInit:
5500     return false;
5501
5502   case InitializedEntity::EK_Parameter:
5503   case InitializedEntity::EK_Parameter_CF_Audited:
5504   case InitializedEntity::EK_Temporary:
5505   case InitializedEntity::EK_RelatedResult:
5506   case InitializedEntity::EK_Binding:
5507     return true;
5508   }
5509
5510   llvm_unreachable("missed an InitializedEntity kind?");
5511 }
5512
5513 /// \brief Whether the given entity, when initialized with an object
5514 /// created for that initialization, requires destruction.
5515 static bool shouldDestroyEntity(const InitializedEntity &Entity) {
5516   switch (Entity.getKind()) {
5517     case InitializedEntity::EK_Result:
5518     case InitializedEntity::EK_New:
5519     case InitializedEntity::EK_Base:
5520     case InitializedEntity::EK_Delegating:
5521     case InitializedEntity::EK_VectorElement:
5522     case InitializedEntity::EK_ComplexElement:
5523     case InitializedEntity::EK_BlockElement:
5524     case InitializedEntity::EK_LambdaCapture:
5525       return false;
5526
5527     case InitializedEntity::EK_Member:
5528     case InitializedEntity::EK_Binding:
5529     case InitializedEntity::EK_Variable:
5530     case InitializedEntity::EK_Parameter:
5531     case InitializedEntity::EK_Parameter_CF_Audited:
5532     case InitializedEntity::EK_Temporary:
5533     case InitializedEntity::EK_ArrayElement:
5534     case InitializedEntity::EK_Exception:
5535     case InitializedEntity::EK_CompoundLiteralInit:
5536     case InitializedEntity::EK_RelatedResult:
5537       return true;
5538   }
5539
5540   llvm_unreachable("missed an InitializedEntity kind?");
5541 }
5542
5543 /// \brief Get the location at which initialization diagnostics should appear.
5544 static SourceLocation getInitializationLoc(const InitializedEntity &Entity,
5545                                            Expr *Initializer) {
5546   switch (Entity.getKind()) {
5547   case InitializedEntity::EK_Result:
5548     return Entity.getReturnLoc();
5549
5550   case InitializedEntity::EK_Exception:
5551     return Entity.getThrowLoc();
5552
5553   case InitializedEntity::EK_Variable:
5554   case InitializedEntity::EK_Binding:
5555     return Entity.getDecl()->getLocation();
5556
5557   case InitializedEntity::EK_LambdaCapture:
5558     return Entity.getCaptureLoc();
5559
5560   case InitializedEntity::EK_ArrayElement:
5561   case InitializedEntity::EK_Member:
5562   case InitializedEntity::EK_Parameter:
5563   case InitializedEntity::EK_Parameter_CF_Audited:
5564   case InitializedEntity::EK_Temporary:
5565   case InitializedEntity::EK_New:
5566   case InitializedEntity::EK_Base:
5567   case InitializedEntity::EK_Delegating:
5568   case InitializedEntity::EK_VectorElement:
5569   case InitializedEntity::EK_ComplexElement:
5570   case InitializedEntity::EK_BlockElement:
5571   case InitializedEntity::EK_CompoundLiteralInit:
5572   case InitializedEntity::EK_RelatedResult:
5573     return Initializer->getLocStart();
5574   }
5575   llvm_unreachable("missed an InitializedEntity kind?");
5576 }
5577
5578 /// \brief Make a (potentially elidable) temporary copy of the object
5579 /// provided by the given initializer by calling the appropriate copy
5580 /// constructor.
5581 ///
5582 /// \param S The Sema object used for type-checking.
5583 ///
5584 /// \param T The type of the temporary object, which must either be
5585 /// the type of the initializer expression or a superclass thereof.
5586 ///
5587 /// \param Entity The entity being initialized.
5588 ///
5589 /// \param CurInit The initializer expression.
5590 ///
5591 /// \param IsExtraneousCopy Whether this is an "extraneous" copy that
5592 /// is permitted in C++03 (but not C++0x) when binding a reference to
5593 /// an rvalue.
5594 ///
5595 /// \returns An expression that copies the initializer expression into
5596 /// a temporary object, or an error expression if a copy could not be
5597 /// created.
5598 static ExprResult CopyObject(Sema &S,
5599                              QualType T,
5600                              const InitializedEntity &Entity,
5601                              ExprResult CurInit,
5602                              bool IsExtraneousCopy) {
5603   if (CurInit.isInvalid())
5604     return CurInit;
5605   // Determine which class type we're copying to.
5606   Expr *CurInitExpr = (Expr *)CurInit.get();
5607   CXXRecordDecl *Class = nullptr;
5608   if (const RecordType *Record = T->getAs<RecordType>())
5609     Class = cast<CXXRecordDecl>(Record->getDecl());
5610   if (!Class)
5611     return CurInit;
5612
5613   SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
5614
5615   // Make sure that the type we are copying is complete.
5616   if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
5617     return CurInit;
5618
5619   // Perform overload resolution using the class's constructors. Per
5620   // C++11 [dcl.init]p16, second bullet for class types, this initialization
5621   // is direct-initialization.
5622   OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5623   DeclContext::lookup_result Ctors = S.LookupConstructors(Class);
5624
5625   OverloadCandidateSet::iterator Best;
5626   switch (ResolveConstructorOverload(
5627       S, Loc, CurInitExpr, CandidateSet, Ctors, Best,
5628       /*CopyInitializing=*/false, /*AllowExplicit=*/true,
5629       /*OnlyListConstructors=*/false, /*IsListInit=*/false,
5630       /*SecondStepOfCopyInit=*/true)) {
5631   case OR_Success:
5632     break;
5633
5634   case OR_No_Viable_Function:
5635     S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
5636            ? diag::ext_rvalue_to_reference_temp_copy_no_viable
5637            : diag::err_temp_copy_no_viable)
5638       << (int)Entity.getKind() << CurInitExpr->getType()
5639       << CurInitExpr->getSourceRange();
5640     CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5641     if (!IsExtraneousCopy || S.isSFINAEContext())
5642       return ExprError();
5643     return CurInit;
5644
5645   case OR_Ambiguous:
5646     S.Diag(Loc, diag::err_temp_copy_ambiguous)
5647       << (int)Entity.getKind() << CurInitExpr->getType()
5648       << CurInitExpr->getSourceRange();
5649     CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5650     return ExprError();
5651
5652   case OR_Deleted:
5653     S.Diag(Loc, diag::err_temp_copy_deleted)
5654       << (int)Entity.getKind() << CurInitExpr->getType()
5655       << CurInitExpr->getSourceRange();
5656     S.NoteDeletedFunction(Best->Function);
5657     return ExprError();
5658   }
5659
5660   bool HadMultipleCandidates = CandidateSet.size() > 1;
5661
5662   CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
5663   SmallVector<Expr*, 8> ConstructorArgs;
5664   CurInit.get(); // Ownership transferred into MultiExprArg, below.
5665
5666   S.CheckConstructorAccess(Loc, Constructor, Best->FoundDecl, Entity,
5667                            IsExtraneousCopy);
5668
5669   if (IsExtraneousCopy) {
5670     // If this is a totally extraneous copy for C++03 reference
5671     // binding purposes, just return the original initialization
5672     // expression. We don't generate an (elided) copy operation here
5673     // because doing so would require us to pass down a flag to avoid
5674     // infinite recursion, where each step adds another extraneous,
5675     // elidable copy.
5676
5677     // Instantiate the default arguments of any extra parameters in
5678     // the selected copy constructor, as if we were going to create a
5679     // proper call to the copy constructor.
5680     for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
5681       ParmVarDecl *Parm = Constructor->getParamDecl(I);
5682       if (S.RequireCompleteType(Loc, Parm->getType(),
5683                                 diag::err_call_incomplete_argument))
5684         break;
5685
5686       // Build the default argument expression; we don't actually care
5687       // if this succeeds or not, because this routine will complain
5688       // if there was a problem.
5689       S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
5690     }
5691
5692     return CurInitExpr;
5693   }
5694
5695   // Determine the arguments required to actually perform the
5696   // constructor call (we might have derived-to-base conversions, or
5697   // the copy constructor may have default arguments).
5698   if (S.CompleteConstructorCall(Constructor, CurInitExpr, Loc, ConstructorArgs))
5699     return ExprError();
5700
5701   // C++0x [class.copy]p32:
5702   //   When certain criteria are met, an implementation is allowed to
5703   //   omit the copy/move construction of a class object, even if the
5704   //   copy/move constructor and/or destructor for the object have
5705   //   side effects. [...]
5706   //     - when a temporary class object that has not been bound to a
5707   //       reference (12.2) would be copied/moved to a class object
5708   //       with the same cv-unqualified type, the copy/move operation
5709   //       can be omitted by constructing the temporary object
5710   //       directly into the target of the omitted copy/move
5711   //
5712   // Note that the other three bullets are handled elsewhere. Copy
5713   // elision for return statements and throw expressions are handled as part
5714   // of constructor initialization, while copy elision for exception handlers
5715   // is handled by the run-time.
5716   //
5717   // FIXME: If the function parameter is not the same type as the temporary, we
5718   // should still be able to elide the copy, but we don't have a way to
5719   // represent in the AST how much should be elided in this case.
5720   bool Elidable =
5721       CurInitExpr->isTemporaryObject(S.Context, Class) &&
5722       S.Context.hasSameUnqualifiedType(
5723           Best->Function->getParamDecl(0)->getType().getNonReferenceType(),
5724           CurInitExpr->getType());
5725
5726   // Actually perform the constructor call.
5727   CurInit = S.BuildCXXConstructExpr(Loc, T, Best->FoundDecl, Constructor,
5728                                     Elidable,
5729                                     ConstructorArgs,
5730                                     HadMultipleCandidates,
5731                                     /*ListInit*/ false,
5732                                     /*StdInitListInit*/ false,
5733                                     /*ZeroInit*/ false,
5734                                     CXXConstructExpr::CK_Complete,
5735                                     SourceRange());
5736
5737   // If we're supposed to bind temporaries, do so.
5738   if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
5739     CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
5740   return CurInit;
5741 }
5742
5743 /// \brief Check whether elidable copy construction for binding a reference to
5744 /// a temporary would have succeeded if we were building in C++98 mode, for
5745 /// -Wc++98-compat.
5746 static void CheckCXX98CompatAccessibleCopy(Sema &S,
5747                                            const InitializedEntity &Entity,
5748                                            Expr *CurInitExpr) {
5749   assert(S.getLangOpts().CPlusPlus11);
5750
5751   const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>();
5752   if (!Record)
5753     return;
5754
5755   SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr);
5756   if (S.Diags.isIgnored(diag::warn_cxx98_compat_temp_copy, Loc))
5757     return;
5758
5759   // Find constructors which would have been considered.
5760   OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5761   DeclContext::lookup_result Ctors =
5762       S.LookupConstructors(cast<CXXRecordDecl>(Record->getDecl()));
5763
5764   // Perform overload resolution.
5765   OverloadCandidateSet::iterator Best;
5766   OverloadingResult OR = ResolveConstructorOverload(
5767       S, Loc, CurInitExpr, CandidateSet, Ctors, Best,
5768       /*CopyInitializing=*/false, /*AllowExplicit=*/true,
5769       /*OnlyListConstructors=*/false, /*IsListInit=*/false,
5770       /*SecondStepOfCopyInit=*/true);
5771
5772   PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy)
5773     << OR << (int)Entity.getKind() << CurInitExpr->getType()
5774     << CurInitExpr->getSourceRange();
5775
5776   switch (OR) {
5777   case OR_Success:
5778     S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
5779                              Best->FoundDecl, Entity, Diag);
5780     // FIXME: Check default arguments as far as that's possible.
5781     break;
5782
5783   case OR_No_Viable_Function:
5784     S.Diag(Loc, Diag);
5785     CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5786     break;
5787
5788   case OR_Ambiguous:
5789     S.Diag(Loc, Diag);
5790     CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5791     break;
5792
5793   case OR_Deleted:
5794     S.Diag(Loc, Diag);
5795     S.NoteDeletedFunction(Best->Function);
5796     break;
5797   }
5798 }
5799
5800 void InitializationSequence::PrintInitLocationNote(Sema &S,
5801                                               const InitializedEntity &Entity) {
5802   if (Entity.isParameterKind() && Entity.getDecl()) {
5803     if (Entity.getDecl()->getLocation().isInvalid())
5804       return;
5805
5806     if (Entity.getDecl()->getDeclName())
5807       S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
5808         << Entity.getDecl()->getDeclName();
5809     else
5810       S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
5811   }
5812   else if (Entity.getKind() == InitializedEntity::EK_RelatedResult &&
5813            Entity.getMethodDecl())
5814     S.Diag(Entity.getMethodDecl()->getLocation(),
5815            diag::note_method_return_type_change)
5816       << Entity.getMethodDecl()->getDeclName();
5817 }
5818
5819 /// Returns true if the parameters describe a constructor initialization of
5820 /// an explicit temporary object, e.g. "Point(x, y)".
5821 static bool isExplicitTemporary(const InitializedEntity &Entity,
5822                                 const InitializationKind &Kind,
5823                                 unsigned NumArgs) {
5824   switch (Entity.getKind()) {
5825   case InitializedEntity::EK_Temporary:
5826   case InitializedEntity::EK_CompoundLiteralInit:
5827   case InitializedEntity::EK_RelatedResult:
5828     break;
5829   default:
5830     return false;
5831   }
5832
5833   switch (Kind.getKind()) {
5834   case InitializationKind::IK_DirectList:
5835     return true;
5836   // FIXME: Hack to work around cast weirdness.
5837   case InitializationKind::IK_Direct:
5838   case InitializationKind::IK_Value:
5839     return NumArgs != 1;
5840   default:
5841     return false;
5842   }
5843 }
5844
5845 static ExprResult
5846 PerformConstructorInitialization(Sema &S,
5847                                  const InitializedEntity &Entity,
5848                                  const InitializationKind &Kind,
5849                                  MultiExprArg Args,
5850                                  const InitializationSequence::Step& Step,
5851                                  bool &ConstructorInitRequiresZeroInit,
5852                                  bool IsListInitialization,
5853                                  bool IsStdInitListInitialization,
5854                                  SourceLocation LBraceLoc,
5855                                  SourceLocation RBraceLoc) {
5856   unsigned NumArgs = Args.size();
5857   CXXConstructorDecl *Constructor
5858     = cast<CXXConstructorDecl>(Step.Function.Function);
5859   bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
5860
5861   // Build a call to the selected constructor.
5862   SmallVector<Expr*, 8> ConstructorArgs;
5863   SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
5864                          ? Kind.getEqualLoc()
5865                          : Kind.getLocation();
5866
5867   if (Kind.getKind() == InitializationKind::IK_Default) {
5868     // Force even a trivial, implicit default constructor to be
5869     // semantically checked. We do this explicitly because we don't build
5870     // the definition for completely trivial constructors.
5871     assert(Constructor->getParent() && "No parent class for constructor.");
5872     if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
5873         Constructor->isTrivial() && !Constructor->isUsed(false))
5874       S.DefineImplicitDefaultConstructor(Loc, Constructor);
5875   }
5876
5877   ExprResult CurInit((Expr *)nullptr);
5878
5879   // C++ [over.match.copy]p1:
5880   //   - When initializing a temporary to be bound to the first parameter
5881   //     of a constructor that takes a reference to possibly cv-qualified
5882   //     T as its first argument, called with a single argument in the
5883   //     context of direct-initialization, explicit conversion functions
5884   //     are also considered.
5885   bool AllowExplicitConv =
5886       Kind.AllowExplicit() && !Kind.isCopyInit() && Args.size() == 1 &&
5887       hasCopyOrMoveCtorParam(S.Context,
5888                              getConstructorInfo(Step.Function.FoundDecl));
5889
5890   // Determine the arguments required to actually perform the constructor
5891   // call.
5892   if (S.CompleteConstructorCall(Constructor, Args,
5893                                 Loc, ConstructorArgs,
5894                                 AllowExplicitConv,
5895                                 IsListInitialization))
5896     return ExprError();
5897
5898
5899   if (isExplicitTemporary(Entity, Kind, NumArgs)) {
5900     // An explicitly-constructed temporary, e.g., X(1, 2).
5901     if (S.DiagnoseUseOfDecl(Constructor, Loc))
5902       return ExprError();
5903
5904     TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5905     if (!TSInfo)
5906       TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
5907     SourceRange ParenOrBraceRange =
5908       (Kind.getKind() == InitializationKind::IK_DirectList)
5909       ? SourceRange(LBraceLoc, RBraceLoc)
5910       : Kind.getParenRange();
5911
5912     if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(
5913             Step.Function.FoundDecl.getDecl())) {
5914       Constructor = S.findInheritingConstructor(Loc, Constructor, Shadow);
5915       if (S.DiagnoseUseOfDecl(Constructor, Loc))
5916         return ExprError();
5917     }
5918     S.MarkFunctionReferenced(Loc, Constructor);
5919
5920     CurInit = new (S.Context) CXXTemporaryObjectExpr(
5921         S.Context, Constructor, TSInfo,
5922         ConstructorArgs, ParenOrBraceRange, HadMultipleCandidates,
5923         IsListInitialization, IsStdInitListInitialization,
5924         ConstructorInitRequiresZeroInit);
5925   } else {
5926     CXXConstructExpr::ConstructionKind ConstructKind =
5927       CXXConstructExpr::CK_Complete;
5928
5929     if (Entity.getKind() == InitializedEntity::EK_Base) {
5930       ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
5931         CXXConstructExpr::CK_VirtualBase :
5932         CXXConstructExpr::CK_NonVirtualBase;
5933     } else if (Entity.getKind() == InitializedEntity::EK_Delegating) {
5934       ConstructKind = CXXConstructExpr::CK_Delegating;
5935     }
5936
5937     // Only get the parenthesis or brace range if it is a list initialization or
5938     // direct construction.
5939     SourceRange ParenOrBraceRange;
5940     if (IsListInitialization)
5941       ParenOrBraceRange = SourceRange(LBraceLoc, RBraceLoc);
5942     else if (Kind.getKind() == InitializationKind::IK_Direct)
5943       ParenOrBraceRange = Kind.getParenRange();
5944
5945     // If the entity allows NRVO, mark the construction as elidable
5946     // unconditionally.
5947     if (Entity.allowsNRVO())
5948       CurInit = S.BuildCXXConstructExpr(Loc, Step.Type,
5949                                         Step.Function.FoundDecl,
5950                                         Constructor, /*Elidable=*/true,
5951                                         ConstructorArgs,
5952                                         HadMultipleCandidates,
5953                                         IsListInitialization,
5954                                         IsStdInitListInitialization,
5955                                         ConstructorInitRequiresZeroInit,
5956                                         ConstructKind,
5957                                         ParenOrBraceRange);
5958     else
5959       CurInit = S.BuildCXXConstructExpr(Loc, Step.Type,
5960                                         Step.Function.FoundDecl,
5961                                         Constructor,
5962                                         ConstructorArgs,
5963                                         HadMultipleCandidates,
5964                                         IsListInitialization,
5965                                         IsStdInitListInitialization,
5966                                         ConstructorInitRequiresZeroInit,
5967                                         ConstructKind,
5968                                         ParenOrBraceRange);
5969   }
5970   if (CurInit.isInvalid())
5971     return ExprError();
5972
5973   // Only check access if all of that succeeded.
5974   S.CheckConstructorAccess(Loc, Constructor, Step.Function.FoundDecl, Entity);
5975   if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc))
5976     return ExprError();
5977
5978   if (shouldBindAsTemporary(Entity))
5979     CurInit = S.MaybeBindToTemporary(CurInit.get());
5980
5981   return CurInit;
5982 }
5983
5984 /// Determine whether the specified InitializedEntity definitely has a lifetime
5985 /// longer than the current full-expression. Conservatively returns false if
5986 /// it's unclear.
5987 static bool
5988 InitializedEntityOutlivesFullExpression(const InitializedEntity &Entity) {
5989   const InitializedEntity *Top = &Entity;
5990   while (Top->getParent())
5991     Top = Top->getParent();
5992
5993   switch (Top->getKind()) {
5994   case InitializedEntity::EK_Variable:
5995   case InitializedEntity::EK_Result:
5996   case InitializedEntity::EK_Exception:
5997   case InitializedEntity::EK_Member:
5998   case InitializedEntity::EK_Binding:
5999   case InitializedEntity::EK_New:
6000   case InitializedEntity::EK_Base:
6001   case InitializedEntity::EK_Delegating:
6002     return true;
6003
6004   case InitializedEntity::EK_ArrayElement:
6005   case InitializedEntity::EK_VectorElement:
6006   case InitializedEntity::EK_BlockElement:
6007   case InitializedEntity::EK_ComplexElement:
6008     // Could not determine what the full initialization is. Assume it might not
6009     // outlive the full-expression.
6010     return false;
6011
6012   case InitializedEntity::EK_Parameter:
6013   case InitializedEntity::EK_Parameter_CF_Audited:
6014   case InitializedEntity::EK_Temporary:
6015   case InitializedEntity::EK_LambdaCapture:
6016   case InitializedEntity::EK_CompoundLiteralInit:
6017   case InitializedEntity::EK_RelatedResult:
6018     // The entity being initialized might not outlive the full-expression.
6019     return false;
6020   }
6021
6022   llvm_unreachable("unknown entity kind");
6023 }
6024
6025 /// Determine the declaration which an initialized entity ultimately refers to,
6026 /// for the purpose of lifetime-extending a temporary bound to a reference in
6027 /// the initialization of \p Entity.
6028 static const InitializedEntity *getEntityForTemporaryLifetimeExtension(
6029     const InitializedEntity *Entity,
6030     const InitializedEntity *FallbackDecl = nullptr) {
6031   // C++11 [class.temporary]p5:
6032   switch (Entity->getKind()) {
6033   case InitializedEntity::EK_Variable:
6034     //   The temporary [...] persists for the lifetime of the reference
6035     return Entity;
6036
6037   case InitializedEntity::EK_Member:
6038     // For subobjects, we look at the complete object.
6039     if (Entity->getParent())
6040       return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
6041                                                     Entity);
6042
6043     //   except:
6044     //   -- A temporary bound to a reference member in a constructor's
6045     //      ctor-initializer persists until the constructor exits.
6046     return Entity;
6047
6048   case InitializedEntity::EK_Binding:
6049     // Per [dcl.decomp]p3, the binding is treated as a variable of reference
6050     // type.
6051     return Entity;
6052
6053   case InitializedEntity::EK_Parameter:
6054   case InitializedEntity::EK_Parameter_CF_Audited:
6055     //   -- A temporary bound to a reference parameter in a function call
6056     //      persists until the completion of the full-expression containing
6057     //      the call.
6058   case InitializedEntity::EK_Result:
6059     //   -- The lifetime of a temporary bound to the returned value in a
6060     //      function return statement is not extended; the temporary is
6061     //      destroyed at the end of the full-expression in the return statement.
6062   case InitializedEntity::EK_New:
6063     //   -- A temporary bound to a reference in a new-initializer persists
6064     //      until the completion of the full-expression containing the
6065     //      new-initializer.
6066     return nullptr;
6067
6068   case InitializedEntity::EK_Temporary:
6069   case InitializedEntity::EK_CompoundLiteralInit:
6070   case InitializedEntity::EK_RelatedResult:
6071     // We don't yet know the storage duration of the surrounding temporary.
6072     // Assume it's got full-expression duration for now, it will patch up our
6073     // storage duration if that's not correct.
6074     return nullptr;
6075
6076   case InitializedEntity::EK_ArrayElement:
6077     // For subobjects, we look at the complete object.
6078     return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
6079                                                   FallbackDecl);
6080
6081   case InitializedEntity::EK_Base:
6082     // For subobjects, we look at the complete object.
6083     if (Entity->getParent())
6084       return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
6085                                                     Entity);
6086     // Fall through.
6087   case InitializedEntity::EK_Delegating:
6088     // We can reach this case for aggregate initialization in a constructor:
6089     //   struct A { int &&r; };
6090     //   struct B : A { B() : A{0} {} };
6091     // In this case, use the innermost field decl as the context.
6092     return FallbackDecl;
6093
6094   case InitializedEntity::EK_BlockElement:
6095   case InitializedEntity::EK_LambdaCapture:
6096   case InitializedEntity::EK_Exception:
6097   case InitializedEntity::EK_VectorElement:
6098   case InitializedEntity::EK_ComplexElement:
6099     return nullptr;
6100   }
6101   llvm_unreachable("unknown entity kind");
6102 }
6103
6104 static void performLifetimeExtension(Expr *Init,
6105                                      const InitializedEntity *ExtendingEntity);
6106
6107 /// Update a glvalue expression that is used as the initializer of a reference
6108 /// to note that its lifetime is extended.
6109 /// \return \c true if any temporary had its lifetime extended.
6110 static bool
6111 performReferenceExtension(Expr *Init,
6112                           const InitializedEntity *ExtendingEntity) {
6113   // Walk past any constructs which we can lifetime-extend across.
6114   Expr *Old;
6115   do {
6116     Old = Init;
6117
6118     if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
6119       if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
6120         // This is just redundant braces around an initializer. Step over it.
6121         Init = ILE->getInit(0);
6122       }
6123     }
6124
6125     // Step over any subobject adjustments; we may have a materialized
6126     // temporary inside them.
6127     Init = const_cast<Expr *>(Init->skipRValueSubobjectAdjustments());
6128
6129     // Per current approach for DR1376, look through casts to reference type
6130     // when performing lifetime extension.
6131     if (CastExpr *CE = dyn_cast<CastExpr>(Init))
6132       if (CE->getSubExpr()->isGLValue())
6133         Init = CE->getSubExpr();
6134
6135     // Per the current approach for DR1299, look through array element access
6136     // when performing lifetime extension.
6137     if (auto *ASE = dyn_cast<ArraySubscriptExpr>(Init))
6138       Init = ASE->getBase();
6139   } while (Init != Old);
6140
6141   if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) {
6142     // Update the storage duration of the materialized temporary.
6143     // FIXME: Rebuild the expression instead of mutating it.
6144     ME->setExtendingDecl(ExtendingEntity->getDecl(),
6145                          ExtendingEntity->allocateManglingNumber());
6146     performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingEntity);
6147     return true;
6148   }
6149
6150   return false;
6151 }
6152
6153 /// Update a prvalue expression that is going to be materialized as a
6154 /// lifetime-extended temporary.
6155 static void performLifetimeExtension(Expr *Init,
6156                                      const InitializedEntity *ExtendingEntity) {
6157   // Dig out the expression which constructs the extended temporary.
6158   Init = const_cast<Expr *>(Init->skipRValueSubobjectAdjustments());
6159
6160   if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init))
6161     Init = BTE->getSubExpr();
6162
6163   if (CXXStdInitializerListExpr *ILE =
6164           dyn_cast<CXXStdInitializerListExpr>(Init)) {
6165     performReferenceExtension(ILE->getSubExpr(), ExtendingEntity);
6166     return;
6167   }
6168
6169   if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
6170     if (ILE->getType()->isArrayType()) {
6171       for (unsigned I = 0, N = ILE->getNumInits(); I != N; ++I)
6172         performLifetimeExtension(ILE->getInit(I), ExtendingEntity);
6173       return;
6174     }
6175
6176     if (CXXRecordDecl *RD = ILE->getType()->getAsCXXRecordDecl()) {
6177       assert(RD->isAggregate() && "aggregate init on non-aggregate");
6178
6179       // If we lifetime-extend a braced initializer which is initializing an
6180       // aggregate, and that aggregate contains reference members which are
6181       // bound to temporaries, those temporaries are also lifetime-extended.
6182       if (RD->isUnion() && ILE->getInitializedFieldInUnion() &&
6183           ILE->getInitializedFieldInUnion()->getType()->isReferenceType())
6184         performReferenceExtension(ILE->getInit(0), ExtendingEntity);
6185       else {
6186         unsigned Index = 0;
6187         for (const auto *I : RD->fields()) {
6188           if (Index >= ILE->getNumInits())
6189             break;
6190           if (I->isUnnamedBitfield())
6191             continue;
6192           Expr *SubInit = ILE->getInit(Index);
6193           if (I->getType()->isReferenceType())
6194             performReferenceExtension(SubInit, ExtendingEntity);
6195           else if (isa<InitListExpr>(SubInit) ||
6196                    isa<CXXStdInitializerListExpr>(SubInit))
6197             // This may be either aggregate-initialization of a member or
6198             // initialization of a std::initializer_list object. Either way,
6199             // we should recursively lifetime-extend that initializer.
6200             performLifetimeExtension(SubInit, ExtendingEntity);
6201           ++Index;
6202         }
6203       }
6204     }
6205   }
6206 }
6207
6208 static void warnOnLifetimeExtension(Sema &S, const InitializedEntity &Entity,
6209                                     const Expr *Init, bool IsInitializerList,
6210                                     const ValueDecl *ExtendingDecl) {
6211   // Warn if a field lifetime-extends a temporary.
6212   if (isa<FieldDecl>(ExtendingDecl)) {
6213     if (IsInitializerList) {
6214       S.Diag(Init->getExprLoc(), diag::warn_dangling_std_initializer_list)
6215         << /*at end of constructor*/true;
6216       return;
6217     }
6218
6219     bool IsSubobjectMember = false;
6220     for (const InitializedEntity *Ent = Entity.getParent(); Ent;
6221          Ent = Ent->getParent()) {
6222       if (Ent->getKind() != InitializedEntity::EK_Base) {
6223         IsSubobjectMember = true;
6224         break;
6225       }
6226     }
6227     S.Diag(Init->getExprLoc(),
6228            diag::warn_bind_ref_member_to_temporary)
6229       << ExtendingDecl << Init->getSourceRange()
6230       << IsSubobjectMember << IsInitializerList;
6231     if (IsSubobjectMember)
6232       S.Diag(ExtendingDecl->getLocation(),
6233              diag::note_ref_subobject_of_member_declared_here);
6234     else
6235       S.Diag(ExtendingDecl->getLocation(),
6236              diag::note_ref_or_ptr_member_declared_here)
6237         << /*is pointer*/false;
6238   }
6239 }
6240
6241 static void DiagnoseNarrowingInInitList(Sema &S,
6242                                         const ImplicitConversionSequence &ICS,
6243                                         QualType PreNarrowingType,
6244                                         QualType EntityType,
6245                                         const Expr *PostInit);
6246
6247 /// Provide warnings when std::move is used on construction.
6248 static void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr,
6249                                     bool IsReturnStmt) {
6250   if (!InitExpr)
6251     return;
6252
6253   if (!S.ActiveTemplateInstantiations.empty())
6254     return;
6255
6256   QualType DestType = InitExpr->getType();
6257   if (!DestType->isRecordType())
6258     return;
6259
6260   unsigned DiagID = 0;
6261   if (IsReturnStmt) {
6262     const CXXConstructExpr *CCE =
6263         dyn_cast<CXXConstructExpr>(InitExpr->IgnoreParens());
6264     if (!CCE || CCE->getNumArgs() != 1)
6265       return;
6266
6267     if (!CCE->getConstructor()->isCopyOrMoveConstructor())
6268       return;
6269
6270     InitExpr = CCE->getArg(0)->IgnoreImpCasts();
6271   }
6272
6273   // Find the std::move call and get the argument.
6274   const CallExpr *CE = dyn_cast<CallExpr>(InitExpr->IgnoreParens());
6275   if (!CE || CE->getNumArgs() != 1)
6276     return;
6277
6278   const FunctionDecl *MoveFunction = CE->getDirectCallee();
6279   if (!MoveFunction || !MoveFunction->isInStdNamespace() ||
6280       !MoveFunction->getIdentifier() ||
6281       !MoveFunction->getIdentifier()->isStr("move"))
6282     return;
6283
6284   const Expr *Arg = CE->getArg(0)->IgnoreImplicit();
6285
6286   if (IsReturnStmt) {
6287     const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts());
6288     if (!DRE || DRE->refersToEnclosingVariableOrCapture())
6289       return;
6290
6291     const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl());
6292     if (!VD || !VD->hasLocalStorage())
6293       return;
6294
6295     QualType SourceType = VD->getType();
6296     if (!SourceType->isRecordType())
6297       return;
6298
6299     if (!S.Context.hasSameUnqualifiedType(DestType, SourceType)) {
6300       return;
6301     }
6302
6303     // If we're returning a function parameter, copy elision
6304     // is not possible.
6305     if (isa<ParmVarDecl>(VD))
6306       DiagID = diag::warn_redundant_move_on_return;
6307     else
6308       DiagID = diag::warn_pessimizing_move_on_return;
6309   } else {
6310     DiagID = diag::warn_pessimizing_move_on_initialization;
6311     const Expr *ArgStripped = Arg->IgnoreImplicit()->IgnoreParens();
6312     if (!ArgStripped->isRValue() || !ArgStripped->getType()->isRecordType())
6313       return;
6314   }
6315
6316   S.Diag(CE->getLocStart(), DiagID);
6317
6318   // Get all the locations for a fix-it.  Don't emit the fix-it if any location
6319   // is within a macro.
6320   SourceLocation CallBegin = CE->getCallee()->getLocStart();
6321   if (CallBegin.isMacroID())
6322     return;
6323   SourceLocation RParen = CE->getRParenLoc();
6324   if (RParen.isMacroID())
6325     return;
6326   SourceLocation LParen;
6327   SourceLocation ArgLoc = Arg->getLocStart();
6328
6329   // Special testing for the argument location.  Since the fix-it needs the
6330   // location right before the argument, the argument location can be in a
6331   // macro only if it is at the beginning of the macro.
6332   while (ArgLoc.isMacroID() &&
6333          S.getSourceManager().isAtStartOfImmediateMacroExpansion(ArgLoc)) {
6334     ArgLoc = S.getSourceManager().getImmediateExpansionRange(ArgLoc).first;
6335   }
6336
6337   if (LParen.isMacroID())
6338     return;
6339
6340   LParen = ArgLoc.getLocWithOffset(-1);
6341
6342   S.Diag(CE->getLocStart(), diag::note_remove_move)
6343       << FixItHint::CreateRemoval(SourceRange(CallBegin, LParen))
6344       << FixItHint::CreateRemoval(SourceRange(RParen, RParen));
6345 }
6346
6347 static void CheckForNullPointerDereference(Sema &S, const Expr *E) {
6348   // Check to see if we are dereferencing a null pointer.  If so, this is
6349   // undefined behavior, so warn about it.  This only handles the pattern
6350   // "*null", which is a very syntactic check.
6351   if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts()))
6352     if (UO->getOpcode() == UO_Deref &&
6353         UO->getSubExpr()->IgnoreParenCasts()->
6354         isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull)) {
6355     S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO,
6356                           S.PDiag(diag::warn_binding_null_to_reference)
6357                             << UO->getSubExpr()->getSourceRange());
6358   }
6359 }
6360
6361 MaterializeTemporaryExpr *
6362 Sema::CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,
6363                                      bool BoundToLvalueReference) {
6364   auto MTE = new (Context)
6365       MaterializeTemporaryExpr(T, Temporary, BoundToLvalueReference);
6366
6367   // Order an ExprWithCleanups for lifetime marks.
6368   //
6369   // TODO: It'll be good to have a single place to check the access of the
6370   // destructor and generate ExprWithCleanups for various uses. Currently these
6371   // are done in both CreateMaterializeTemporaryExpr and MaybeBindToTemporary,
6372   // but there may be a chance to merge them.
6373   Cleanup.setExprNeedsCleanups(false);
6374   return MTE;
6375 }
6376
6377 ExprResult Sema::TemporaryMaterializationConversion(Expr *E) {
6378   // In C++98, we don't want to implicitly create an xvalue.
6379   // FIXME: This means that AST consumers need to deal with "prvalues" that
6380   // denote materialized temporaries. Maybe we should add another ValueKind
6381   // for "xvalue pretending to be a prvalue" for C++98 support.
6382   if (!E->isRValue() || !getLangOpts().CPlusPlus11)
6383     return E;
6384
6385   // C++1z [conv.rval]/1: T shall be a complete type.
6386   // FIXME: Does this ever matter (can we form a prvalue of incomplete type)?
6387   // If so, we should check for a non-abstract class type here too.
6388   QualType T = E->getType();
6389   if (RequireCompleteType(E->getExprLoc(), T, diag::err_incomplete_type))
6390     return ExprError();
6391
6392   return CreateMaterializeTemporaryExpr(E->getType(), E, false);
6393 }
6394
6395 ExprResult
6396 InitializationSequence::Perform(Sema &S,
6397                                 const InitializedEntity &Entity,
6398                                 const InitializationKind &Kind,
6399                                 MultiExprArg Args,
6400                                 QualType *ResultType) {
6401   if (Failed()) {
6402     Diagnose(S, Entity, Kind, Args);
6403     return ExprError();
6404   }
6405   if (!ZeroInitializationFixit.empty()) {
6406     unsigned DiagID = diag::err_default_init_const;
6407     if (Decl *D = Entity.getDecl())
6408       if (S.getLangOpts().MSVCCompat && D->hasAttr<SelectAnyAttr>())
6409         DiagID = diag::ext_default_init_const;
6410
6411     // The initialization would have succeeded with this fixit. Since the fixit
6412     // is on the error, we need to build a valid AST in this case, so this isn't
6413     // handled in the Failed() branch above.
6414     QualType DestType = Entity.getType();
6415     S.Diag(Kind.getLocation(), DiagID)
6416         << DestType << (bool)DestType->getAs<RecordType>()
6417         << FixItHint::CreateInsertion(ZeroInitializationFixitLoc,
6418                                       ZeroInitializationFixit);
6419   }
6420
6421   if (getKind() == DependentSequence) {
6422     // If the declaration is a non-dependent, incomplete array type
6423     // that has an initializer, then its type will be completed once
6424     // the initializer is instantiated.
6425     if (ResultType && !Entity.getType()->isDependentType() &&
6426         Args.size() == 1) {
6427       QualType DeclType = Entity.getType();
6428       if (const IncompleteArrayType *ArrayT
6429                            = S.Context.getAsIncompleteArrayType(DeclType)) {
6430         // FIXME: We don't currently have the ability to accurately
6431         // compute the length of an initializer list without
6432         // performing full type-checking of the initializer list
6433         // (since we have to determine where braces are implicitly
6434         // introduced and such).  So, we fall back to making the array
6435         // type a dependently-sized array type with no specified
6436         // bound.
6437         if (isa<InitListExpr>((Expr *)Args[0])) {
6438           SourceRange Brackets;
6439
6440           // Scavange the location of the brackets from the entity, if we can.
6441           if (auto *DD = dyn_cast_or_null<DeclaratorDecl>(Entity.getDecl())) {
6442             if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
6443               TypeLoc TL = TInfo->getTypeLoc();
6444               if (IncompleteArrayTypeLoc ArrayLoc =
6445                       TL.getAs<IncompleteArrayTypeLoc>())
6446                 Brackets = ArrayLoc.getBracketsRange();
6447             }
6448           }
6449
6450           *ResultType
6451             = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
6452                                                    /*NumElts=*/nullptr,
6453                                                    ArrayT->getSizeModifier(),
6454                                        ArrayT->getIndexTypeCVRQualifiers(),
6455                                                    Brackets);
6456         }
6457
6458       }
6459     }
6460     if (Kind.getKind() == InitializationKind::IK_Direct &&
6461         !Kind.isExplicitCast()) {
6462       // Rebuild the ParenListExpr.
6463       SourceRange ParenRange = Kind.getParenRange();
6464       return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(),
6465                                   Args);
6466     }
6467     assert(Kind.getKind() == InitializationKind::IK_Copy ||
6468            Kind.isExplicitCast() ||
6469            Kind.getKind() == InitializationKind::IK_DirectList);
6470     return ExprResult(Args[0]);
6471   }
6472
6473   // No steps means no initialization.
6474   if (Steps.empty())
6475     return ExprResult((Expr *)nullptr);
6476
6477   if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
6478       Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
6479       !Entity.isParameterKind()) {
6480     // Produce a C++98 compatibility warning if we are initializing a reference
6481     // from an initializer list. For parameters, we produce a better warning
6482     // elsewhere.
6483     Expr *Init = Args[0];
6484     S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
6485       << Init->getSourceRange();
6486   }
6487
6488   // Diagnose cases where we initialize a pointer to an array temporary, and the
6489   // pointer obviously outlives the temporary.
6490   if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
6491       Entity.getType()->isPointerType() &&
6492       InitializedEntityOutlivesFullExpression(Entity)) {
6493     const Expr *Init = Args[0]->skipRValueSubobjectAdjustments();
6494     if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Init))
6495       Init = MTE->GetTemporaryExpr();
6496     Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context);
6497     if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
6498       S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
6499         << Init->getSourceRange();
6500   }
6501
6502   QualType DestType = Entity.getType().getNonReferenceType();
6503   // FIXME: Ugly hack around the fact that Entity.getType() is not
6504   // the same as Entity.getDecl()->getType() in cases involving type merging,
6505   //  and we want latter when it makes sense.
6506   if (ResultType)
6507     *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
6508                                      Entity.getType();
6509
6510   ExprResult CurInit((Expr *)nullptr);
6511   SmallVector<Expr*, 4> ArrayLoopCommonExprs;
6512
6513   // For initialization steps that start with a single initializer,
6514   // grab the only argument out the Args and place it into the "current"
6515   // initializer.
6516   switch (Steps.front().Kind) {
6517   case SK_ResolveAddressOfOverloadedFunction:
6518   case SK_CastDerivedToBaseRValue:
6519   case SK_CastDerivedToBaseXValue:
6520   case SK_CastDerivedToBaseLValue:
6521   case SK_BindReference:
6522   case SK_BindReferenceToTemporary:
6523   case SK_FinalCopy:
6524   case SK_ExtraneousCopyToTemporary:
6525   case SK_UserConversion:
6526   case SK_QualificationConversionLValue:
6527   case SK_QualificationConversionXValue:
6528   case SK_QualificationConversionRValue:
6529   case SK_AtomicConversion:
6530   case SK_LValueToRValue:
6531   case SK_ConversionSequence:
6532   case SK_ConversionSequenceNoNarrowing:
6533   case SK_ListInitialization:
6534   case SK_UnwrapInitList:
6535   case SK_RewrapInitList:
6536   case SK_CAssignment:
6537   case SK_StringInit:
6538   case SK_ObjCObjectConversion:
6539   case SK_ArrayLoopIndex:
6540   case SK_ArrayLoopInit:
6541   case SK_ArrayInit:
6542   case SK_GNUArrayInit:
6543   case SK_ParenthesizedArrayInit:
6544   case SK_PassByIndirectCopyRestore:
6545   case SK_PassByIndirectRestore:
6546   case SK_ProduceObjCObject:
6547   case SK_StdInitializerList:
6548   case SK_OCLSamplerInit:
6549   case SK_OCLZeroEvent:
6550   case SK_OCLZeroQueue: {
6551     assert(Args.size() == 1);
6552     CurInit = Args[0];
6553     if (!CurInit.get()) return ExprError();
6554     break;
6555   }
6556
6557   case SK_ConstructorInitialization:
6558   case SK_ConstructorInitializationFromList:
6559   case SK_StdInitializerListConstructorCall:
6560   case SK_ZeroInitialization:
6561     break;
6562   }
6563
6564   // Promote from an unevaluated context to an unevaluated list context in
6565   // C++11 list-initialization; we need to instantiate entities usable in
6566   // constant expressions here in order to perform narrowing checks =(
6567   EnterExpressionEvaluationContext Evaluated(
6568       S, EnterExpressionEvaluationContext::InitList,
6569       CurInit.get() && isa<InitListExpr>(CurInit.get()));
6570
6571   // C++ [class.abstract]p2:
6572   //   no objects of an abstract class can be created except as subobjects
6573   //   of a class derived from it
6574   auto checkAbstractType = [&](QualType T) -> bool {
6575     if (Entity.getKind() == InitializedEntity::EK_Base ||
6576         Entity.getKind() == InitializedEntity::EK_Delegating)
6577       return false;
6578     return S.RequireNonAbstractType(Kind.getLocation(), T,
6579                                     diag::err_allocation_of_abstract_type);
6580   };
6581
6582   // Walk through the computed steps for the initialization sequence,
6583   // performing the specified conversions along the way.
6584   bool ConstructorInitRequiresZeroInit = false;
6585   for (step_iterator Step = step_begin(), StepEnd = step_end();
6586        Step != StepEnd; ++Step) {
6587     if (CurInit.isInvalid())
6588       return ExprError();
6589
6590     QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
6591
6592     switch (Step->Kind) {
6593     case SK_ResolveAddressOfOverloadedFunction:
6594       // Overload resolution determined which function invoke; update the
6595       // initializer to reflect that choice.
6596       S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
6597       if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()))
6598         return ExprError();
6599       CurInit = S.FixOverloadedFunctionReference(CurInit,
6600                                                  Step->Function.FoundDecl,
6601                                                  Step->Function.Function);
6602       break;
6603
6604     case SK_CastDerivedToBaseRValue:
6605     case SK_CastDerivedToBaseXValue:
6606     case SK_CastDerivedToBaseLValue: {
6607       // We have a derived-to-base cast that produces either an rvalue or an
6608       // lvalue. Perform that cast.
6609
6610       CXXCastPath BasePath;
6611
6612       // Casts to inaccessible base classes are allowed with C-style casts.
6613       bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
6614       if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
6615                                          CurInit.get()->getLocStart(),
6616                                          CurInit.get()->getSourceRange(),
6617                                          &BasePath, IgnoreBaseAccess))
6618         return ExprError();
6619
6620       ExprValueKind VK =
6621           Step->Kind == SK_CastDerivedToBaseLValue ?
6622               VK_LValue :
6623               (Step->Kind == SK_CastDerivedToBaseXValue ?
6624                    VK_XValue :
6625                    VK_RValue);
6626       CurInit =
6627           ImplicitCastExpr::Create(S.Context, Step->Type, CK_DerivedToBase,
6628                                    CurInit.get(), &BasePath, VK);
6629       break;
6630     }
6631
6632     case SK_BindReference:
6633       // Reference binding does not have any corresponding ASTs.
6634
6635       // Check exception specifications
6636       if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
6637         return ExprError();
6638
6639       // Even though we didn't materialize a temporary, the binding may still
6640       // extend the lifetime of a temporary. This happens if we bind a reference
6641       // to the result of a cast to reference type.
6642       if (const InitializedEntity *ExtendingEntity =
6643               getEntityForTemporaryLifetimeExtension(&Entity))
6644         if (performReferenceExtension(CurInit.get(), ExtendingEntity))
6645           warnOnLifetimeExtension(S, Entity, CurInit.get(),
6646                                   /*IsInitializerList=*/false,
6647                                   ExtendingEntity->getDecl());
6648
6649       CheckForNullPointerDereference(S, CurInit.get());
6650       break;
6651
6652     case SK_BindReferenceToTemporary: {
6653       // Make sure the "temporary" is actually an rvalue.
6654       assert(CurInit.get()->isRValue() && "not a temporary");
6655
6656       // Check exception specifications
6657       if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
6658         return ExprError();
6659
6660       // Materialize the temporary into memory.
6661       MaterializeTemporaryExpr *MTE = S.CreateMaterializeTemporaryExpr(
6662           Step->Type, CurInit.get(), Entity.getType()->isLValueReferenceType());
6663
6664       // Maybe lifetime-extend the temporary's subobjects to match the
6665       // entity's lifetime.
6666       if (const InitializedEntity *ExtendingEntity =
6667               getEntityForTemporaryLifetimeExtension(&Entity))
6668         if (performReferenceExtension(MTE, ExtendingEntity))
6669           warnOnLifetimeExtension(S, Entity, CurInit.get(),
6670                                   /*IsInitializerList=*/false,
6671                                   ExtendingEntity->getDecl());
6672
6673       // If we're binding to an Objective-C object that has lifetime, we
6674       // need cleanups. Likewise if we're extending this temporary to automatic
6675       // storage duration -- we need to register its cleanup during the
6676       // full-expression's cleanups.
6677       if ((S.getLangOpts().ObjCAutoRefCount &&
6678            MTE->getType()->isObjCLifetimeType()) ||
6679           (MTE->getStorageDuration() == SD_Automatic &&
6680            MTE->getType().isDestructedType()))
6681         S.Cleanup.setExprNeedsCleanups(true);
6682
6683       CurInit = MTE;
6684       break;
6685     }
6686
6687     case SK_FinalCopy:
6688       if (checkAbstractType(Step->Type))
6689         return ExprError();
6690
6691       // If the overall initialization is initializing a temporary, we already
6692       // bound our argument if it was necessary to do so. If not (if we're
6693       // ultimately initializing a non-temporary), our argument needs to be
6694       // bound since it's initializing a function parameter.
6695       // FIXME: This is a mess. Rationalize temporary destruction.
6696       if (!shouldBindAsTemporary(Entity))
6697         CurInit = S.MaybeBindToTemporary(CurInit.get());
6698       CurInit = CopyObject(S, Step->Type, Entity, CurInit,
6699                            /*IsExtraneousCopy=*/false);
6700       break;
6701
6702     case SK_ExtraneousCopyToTemporary:
6703       CurInit = CopyObject(S, Step->Type, Entity, CurInit,
6704                            /*IsExtraneousCopy=*/true);
6705       break;
6706
6707     case SK_UserConversion: {
6708       // We have a user-defined conversion that invokes either a constructor
6709       // or a conversion function.
6710       CastKind CastKind;
6711       FunctionDecl *Fn = Step->Function.Function;
6712       DeclAccessPair FoundFn = Step->Function.FoundDecl;
6713       bool HadMultipleCandidates = Step->Function.HadMultipleCandidates;
6714       bool CreatedObject = false;
6715       if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
6716         // Build a call to the selected constructor.
6717         SmallVector<Expr*, 8> ConstructorArgs;
6718         SourceLocation Loc = CurInit.get()->getLocStart();
6719
6720         // Determine the arguments required to actually perform the constructor
6721         // call.
6722         Expr *Arg = CurInit.get();
6723         if (S.CompleteConstructorCall(Constructor,
6724                                       MultiExprArg(&Arg, 1),
6725                                       Loc, ConstructorArgs))
6726           return ExprError();
6727
6728         // Build an expression that constructs a temporary.
6729         CurInit = S.BuildCXXConstructExpr(Loc, Step->Type,
6730                                           FoundFn, Constructor,
6731                                           ConstructorArgs,
6732                                           HadMultipleCandidates,
6733                                           /*ListInit*/ false,
6734                                           /*StdInitListInit*/ false,
6735                                           /*ZeroInit*/ false,
6736                                           CXXConstructExpr::CK_Complete,
6737                                           SourceRange());
6738         if (CurInit.isInvalid())
6739           return ExprError();
6740
6741         S.CheckConstructorAccess(Kind.getLocation(), Constructor, FoundFn,
6742                                  Entity);
6743         if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
6744           return ExprError();
6745
6746         CastKind = CK_ConstructorConversion;
6747         CreatedObject = true;
6748       } else {
6749         // Build a call to the conversion function.
6750         CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
6751         S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), nullptr,
6752                                     FoundFn);
6753         if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
6754           return ExprError();
6755
6756         // FIXME: Should we move this initialization into a separate
6757         // derived-to-base conversion? I believe the answer is "no", because
6758         // we don't want to turn off access control here for c-style casts.
6759         CurInit = S.PerformObjectArgumentInitialization(CurInit.get(),
6760                                                         /*Qualifier=*/nullptr,
6761                                                         FoundFn, Conversion);
6762         if (CurInit.isInvalid())
6763           return ExprError();
6764
6765         // Build the actual call to the conversion function.
6766         CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion,
6767                                            HadMultipleCandidates);
6768         if (CurInit.isInvalid())
6769           return ExprError();
6770
6771         CastKind = CK_UserDefinedConversion;
6772         CreatedObject = Conversion->getReturnType()->isRecordType();
6773       }
6774
6775       if (CreatedObject && checkAbstractType(CurInit.get()->getType()))
6776         return ExprError();
6777
6778       CurInit = ImplicitCastExpr::Create(S.Context, CurInit.get()->getType(),
6779                                          CastKind, CurInit.get(), nullptr,
6780                                          CurInit.get()->getValueKind());
6781
6782       if (shouldBindAsTemporary(Entity))
6783         // The overall entity is temporary, so this expression should be
6784         // destroyed at the end of its full-expression.
6785         CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
6786       else if (CreatedObject && shouldDestroyEntity(Entity)) {
6787         // The object outlasts the full-expression, but we need to prepare for
6788         // a destructor being run on it.
6789         // FIXME: It makes no sense to do this here. This should happen
6790         // regardless of how we initialized the entity.
6791         QualType T = CurInit.get()->getType();
6792         if (const RecordType *Record = T->getAs<RecordType>()) {
6793           CXXDestructorDecl *Destructor
6794             = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl()));
6795           S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor,
6796                                   S.PDiag(diag::err_access_dtor_temp) << T);
6797           S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor);
6798           if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart()))
6799             return ExprError();
6800         }
6801       }
6802       break;
6803     }
6804
6805     case SK_QualificationConversionLValue:
6806     case SK_QualificationConversionXValue:
6807     case SK_QualificationConversionRValue: {
6808       // Perform a qualification conversion; these can never go wrong.
6809       ExprValueKind VK =
6810           Step->Kind == SK_QualificationConversionLValue ?
6811               VK_LValue :
6812               (Step->Kind == SK_QualificationConversionXValue ?
6813                    VK_XValue :
6814                    VK_RValue);
6815       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type, CK_NoOp, VK);
6816       break;
6817     }
6818
6819     case SK_AtomicConversion: {
6820       assert(CurInit.get()->isRValue() && "cannot convert glvalue to atomic");
6821       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6822                                     CK_NonAtomicToAtomic, VK_RValue);
6823       break;
6824     }
6825
6826     case SK_LValueToRValue: {
6827       assert(CurInit.get()->isGLValue() && "cannot load from a prvalue");
6828       CurInit = ImplicitCastExpr::Create(S.Context, Step->Type,
6829                                          CK_LValueToRValue, CurInit.get(),
6830                                          /*BasePath=*/nullptr, VK_RValue);
6831       break;
6832     }
6833
6834     case SK_ConversionSequence:
6835     case SK_ConversionSequenceNoNarrowing: {
6836       Sema::CheckedConversionKind CCK
6837         = Kind.isCStyleCast()? Sema::CCK_CStyleCast
6838         : Kind.isFunctionalCast()? Sema::CCK_FunctionalCast
6839         : Kind.isExplicitCast()? Sema::CCK_OtherCast
6840         : Sema::CCK_ImplicitConversion;
6841       ExprResult CurInitExprRes =
6842         S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,
6843                                     getAssignmentAction(Entity), CCK);
6844       if (CurInitExprRes.isInvalid())
6845         return ExprError();
6846
6847       S.DiscardMisalignedMemberAddress(Step->Type.getTypePtr(), CurInit.get());
6848
6849       CurInit = CurInitExprRes;
6850
6851       if (Step->Kind == SK_ConversionSequenceNoNarrowing &&
6852           S.getLangOpts().CPlusPlus)
6853         DiagnoseNarrowingInInitList(S, *Step->ICS, SourceType, Entity.getType(),
6854                                     CurInit.get());
6855
6856       break;
6857     }
6858
6859     case SK_ListInitialization: {
6860       if (checkAbstractType(Step->Type))
6861         return ExprError();
6862
6863       InitListExpr *InitList = cast<InitListExpr>(CurInit.get());
6864       // If we're not initializing the top-level entity, we need to create an
6865       // InitializeTemporary entity for our target type.
6866       QualType Ty = Step->Type;
6867       bool IsTemporary = !S.Context.hasSameType(Entity.getType(), Ty);
6868       InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(Ty);
6869       InitializedEntity InitEntity = IsTemporary ? TempEntity : Entity;
6870       InitListChecker PerformInitList(S, InitEntity,
6871           InitList, Ty, /*VerifyOnly=*/false,
6872           /*TreatUnavailableAsInvalid=*/false);
6873       if (PerformInitList.HadError())
6874         return ExprError();
6875
6876       // Hack: We must update *ResultType if available in order to set the
6877       // bounds of arrays, e.g. in 'int ar[] = {1, 2, 3};'.
6878       // Worst case: 'const int (&arref)[] = {1, 2, 3};'.
6879       if (ResultType &&
6880           ResultType->getNonReferenceType()->isIncompleteArrayType()) {
6881         if ((*ResultType)->isRValueReferenceType())
6882           Ty = S.Context.getRValueReferenceType(Ty);
6883         else if ((*ResultType)->isLValueReferenceType())
6884           Ty = S.Context.getLValueReferenceType(Ty,
6885             (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue());
6886         *ResultType = Ty;
6887       }
6888
6889       InitListExpr *StructuredInitList =
6890           PerformInitList.getFullyStructuredList();
6891       CurInit.get();
6892       CurInit = shouldBindAsTemporary(InitEntity)
6893           ? S.MaybeBindToTemporary(StructuredInitList)
6894           : StructuredInitList;
6895       break;
6896     }
6897
6898     case SK_ConstructorInitializationFromList: {
6899       if (checkAbstractType(Step->Type))
6900         return ExprError();
6901
6902       // When an initializer list is passed for a parameter of type "reference
6903       // to object", we don't get an EK_Temporary entity, but instead an
6904       // EK_Parameter entity with reference type.
6905       // FIXME: This is a hack. What we really should do is create a user
6906       // conversion step for this case, but this makes it considerably more
6907       // complicated. For now, this will do.
6908       InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6909                                         Entity.getType().getNonReferenceType());
6910       bool UseTemporary = Entity.getType()->isReferenceType();
6911       assert(Args.size() == 1 && "expected a single argument for list init");
6912       InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6913       S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
6914         << InitList->getSourceRange();
6915       MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
6916       CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
6917                                                                    Entity,
6918                                                  Kind, Arg, *Step,
6919                                                ConstructorInitRequiresZeroInit,
6920                                                /*IsListInitialization*/true,
6921                                                /*IsStdInitListInit*/false,
6922                                                InitList->getLBraceLoc(),
6923                                                InitList->getRBraceLoc());
6924       break;
6925     }
6926
6927     case SK_UnwrapInitList:
6928       CurInit = cast<InitListExpr>(CurInit.get())->getInit(0);
6929       break;
6930
6931     case SK_RewrapInitList: {
6932       Expr *E = CurInit.get();
6933       InitListExpr *Syntactic = Step->WrappingSyntacticList;
6934       InitListExpr *ILE = new (S.Context) InitListExpr(S.Context,
6935           Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc());
6936       ILE->setSyntacticForm(Syntactic);
6937       ILE->setType(E->getType());
6938       ILE->setValueKind(E->getValueKind());
6939       CurInit = ILE;
6940       break;
6941     }
6942
6943     case SK_ConstructorInitialization:
6944     case SK_StdInitializerListConstructorCall: {
6945       if (checkAbstractType(Step->Type))
6946         return ExprError();
6947
6948       // When an initializer list is passed for a parameter of type "reference
6949       // to object", we don't get an EK_Temporary entity, but instead an
6950       // EK_Parameter entity with reference type.
6951       // FIXME: This is a hack. What we really should do is create a user
6952       // conversion step for this case, but this makes it considerably more
6953       // complicated. For now, this will do.
6954       InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6955                                         Entity.getType().getNonReferenceType());
6956       bool UseTemporary = Entity.getType()->isReferenceType();
6957       bool IsStdInitListInit =
6958           Step->Kind == SK_StdInitializerListConstructorCall;
6959       Expr *Source = CurInit.get();
6960       CurInit = PerformConstructorInitialization(
6961           S, UseTemporary ? TempEntity : Entity, Kind,
6962           Source ? MultiExprArg(Source) : Args, *Step,
6963           ConstructorInitRequiresZeroInit,
6964           /*IsListInitialization*/ IsStdInitListInit,
6965           /*IsStdInitListInitialization*/ IsStdInitListInit,
6966           /*LBraceLoc*/ SourceLocation(),
6967           /*RBraceLoc*/ SourceLocation());
6968       break;
6969     }
6970
6971     case SK_ZeroInitialization: {
6972       step_iterator NextStep = Step;
6973       ++NextStep;
6974       if (NextStep != StepEnd &&
6975           (NextStep->Kind == SK_ConstructorInitialization ||
6976            NextStep->Kind == SK_ConstructorInitializationFromList)) {
6977         // The need for zero-initialization is recorded directly into
6978         // the call to the object's constructor within the next step.
6979         ConstructorInitRequiresZeroInit = true;
6980       } else if (Kind.getKind() == InitializationKind::IK_Value &&
6981                  S.getLangOpts().CPlusPlus &&
6982                  !Kind.isImplicitValueInit()) {
6983         TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
6984         if (!TSInfo)
6985           TSInfo = S.Context.getTrivialTypeSourceInfo(Step->Type,
6986                                                     Kind.getRange().getBegin());
6987
6988         CurInit = new (S.Context) CXXScalarValueInitExpr(
6989             TSInfo->getType().getNonLValueExprType(S.Context), TSInfo,
6990             Kind.getRange().getEnd());
6991       } else {
6992         CurInit = new (S.Context) ImplicitValueInitExpr(Step->Type);
6993       }
6994       break;
6995     }
6996
6997     case SK_CAssignment: {
6998       QualType SourceType = CurInit.get()->getType();
6999       // Save off the initial CurInit in case we need to emit a diagnostic
7000       ExprResult InitialCurInit = CurInit;
7001       ExprResult Result = CurInit;
7002       Sema::AssignConvertType ConvTy =
7003         S.CheckSingleAssignmentConstraints(Step->Type, Result, true,
7004             Entity.getKind() == InitializedEntity::EK_Parameter_CF_Audited);
7005       if (Result.isInvalid())
7006         return ExprError();
7007       CurInit = Result;
7008
7009       // If this is a call, allow conversion to a transparent union.
7010       ExprResult CurInitExprRes = CurInit;
7011       if (ConvTy != Sema::Compatible &&
7012           Entity.isParameterKind() &&
7013           S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExprRes)
7014             == Sema::Compatible)
7015         ConvTy = Sema::Compatible;
7016       if (CurInitExprRes.isInvalid())
7017         return ExprError();
7018       CurInit = CurInitExprRes;
7019
7020       bool Complained;
7021       if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
7022                                      Step->Type, SourceType,
7023                                      InitialCurInit.get(),
7024                                      getAssignmentAction(Entity, true),
7025                                      &Complained)) {
7026         PrintInitLocationNote(S, Entity);
7027         return ExprError();
7028       } else if (Complained)
7029         PrintInitLocationNote(S, Entity);
7030       break;
7031     }
7032
7033     case SK_StringInit: {
7034       QualType Ty = Step->Type;
7035       CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty,
7036                       S.Context.getAsArrayType(Ty), S);
7037       break;
7038     }
7039
7040     case SK_ObjCObjectConversion:
7041       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
7042                           CK_ObjCObjectLValueCast,
7043                           CurInit.get()->getValueKind());
7044       break;
7045
7046     case SK_ArrayLoopIndex: {
7047       Expr *Cur = CurInit.get();
7048       Expr *BaseExpr = new (S.Context)
7049           OpaqueValueExpr(Cur->getExprLoc(), Cur->getType(),
7050                           Cur->getValueKind(), Cur->getObjectKind(), Cur);
7051       Expr *IndexExpr =
7052           new (S.Context) ArrayInitIndexExpr(S.Context.getSizeType());
7053       CurInit = S.CreateBuiltinArraySubscriptExpr(
7054           BaseExpr, Kind.getLocation(), IndexExpr, Kind.getLocation());
7055       ArrayLoopCommonExprs.push_back(BaseExpr);
7056       break;
7057     }
7058
7059     case SK_ArrayLoopInit: {
7060       assert(!ArrayLoopCommonExprs.empty() &&
7061              "mismatched SK_ArrayLoopIndex and SK_ArrayLoopInit");
7062       Expr *Common = ArrayLoopCommonExprs.pop_back_val();
7063       CurInit = new (S.Context) ArrayInitLoopExpr(Step->Type, Common,
7064                                                   CurInit.get());
7065       break;
7066     }
7067
7068     case SK_GNUArrayInit:
7069       // Okay: we checked everything before creating this step. Note that
7070       // this is a GNU extension.
7071       S.Diag(Kind.getLocation(), diag::ext_array_init_copy)
7072         << Step->Type << CurInit.get()->getType()
7073         << CurInit.get()->getSourceRange();
7074       LLVM_FALLTHROUGH;
7075     case SK_ArrayInit:
7076       // If the destination type is an incomplete array type, update the
7077       // type accordingly.
7078       if (ResultType) {
7079         if (const IncompleteArrayType *IncompleteDest
7080                            = S.Context.getAsIncompleteArrayType(Step->Type)) {
7081           if (const ConstantArrayType *ConstantSource
7082                  = S.Context.getAsConstantArrayType(CurInit.get()->getType())) {
7083             *ResultType = S.Context.getConstantArrayType(
7084                                              IncompleteDest->getElementType(),
7085                                              ConstantSource->getSize(),
7086                                              ArrayType::Normal, 0);
7087           }
7088         }
7089       }
7090       break;
7091
7092     case SK_ParenthesizedArrayInit:
7093       // Okay: we checked everything before creating this step. Note that
7094       // this is a GNU extension.
7095       S.Diag(Kind.getLocation(), diag::ext_array_init_parens)
7096         << CurInit.get()->getSourceRange();
7097       break;
7098
7099     case SK_PassByIndirectCopyRestore:
7100     case SK_PassByIndirectRestore:
7101       checkIndirectCopyRestoreSource(S, CurInit.get());
7102       CurInit = new (S.Context) ObjCIndirectCopyRestoreExpr(
7103           CurInit.get(), Step->Type,
7104           Step->Kind == SK_PassByIndirectCopyRestore);
7105       break;
7106
7107     case SK_ProduceObjCObject:
7108       CurInit =
7109           ImplicitCastExpr::Create(S.Context, Step->Type, CK_ARCProduceObject,
7110                                    CurInit.get(), nullptr, VK_RValue);
7111       break;
7112
7113     case SK_StdInitializerList: {
7114       S.Diag(CurInit.get()->getExprLoc(),
7115              diag::warn_cxx98_compat_initializer_list_init)
7116         << CurInit.get()->getSourceRange();
7117
7118       // Materialize the temporary into memory.
7119       MaterializeTemporaryExpr *MTE = S.CreateMaterializeTemporaryExpr(
7120           CurInit.get()->getType(), CurInit.get(),
7121           /*BoundToLvalueReference=*/false);
7122
7123       // Maybe lifetime-extend the array temporary's subobjects to match the
7124       // entity's lifetime.
7125       if (const InitializedEntity *ExtendingEntity =
7126               getEntityForTemporaryLifetimeExtension(&Entity))
7127         if (performReferenceExtension(MTE, ExtendingEntity))
7128           warnOnLifetimeExtension(S, Entity, CurInit.get(),
7129                                   /*IsInitializerList=*/true,
7130                                   ExtendingEntity->getDecl());
7131
7132       // Wrap it in a construction of a std::initializer_list<T>.
7133       CurInit = new (S.Context) CXXStdInitializerListExpr(Step->Type, MTE);
7134
7135       // Bind the result, in case the library has given initializer_list a
7136       // non-trivial destructor.
7137       if (shouldBindAsTemporary(Entity))
7138         CurInit = S.MaybeBindToTemporary(CurInit.get());
7139       break;
7140     }
7141
7142     case SK_OCLSamplerInit: {
7143       // Sampler initialzation have 5 cases:
7144       //   1. function argument passing
7145       //      1a. argument is a file-scope variable
7146       //      1b. argument is a function-scope variable
7147       //      1c. argument is one of caller function's parameters
7148       //   2. variable initialization
7149       //      2a. initializing a file-scope variable
7150       //      2b. initializing a function-scope variable
7151       //
7152       // For file-scope variables, since they cannot be initialized by function
7153       // call of __translate_sampler_initializer in LLVM IR, their references
7154       // need to be replaced by a cast from their literal initializers to
7155       // sampler type. Since sampler variables can only be used in function
7156       // calls as arguments, we only need to replace them when handling the
7157       // argument passing.
7158       assert(Step->Type->isSamplerT() &&
7159              "Sampler initialization on non-sampler type.");
7160       Expr *Init = CurInit.get();
7161       QualType SourceType = Init->getType();
7162       // Case 1
7163       if (Entity.isParameterKind()) {
7164         if (!SourceType->isSamplerT()) {
7165           S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
7166             << SourceType;
7167           break;
7168         } else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init)) {
7169           auto Var = cast<VarDecl>(DRE->getDecl());
7170           // Case 1b and 1c
7171           // No cast from integer to sampler is needed.
7172           if (!Var->hasGlobalStorage()) {
7173             CurInit = ImplicitCastExpr::Create(S.Context, Step->Type,
7174                                                CK_LValueToRValue, Init,
7175                                                /*BasePath=*/nullptr, VK_RValue);
7176             break;
7177           }
7178           // Case 1a
7179           // For function call with a file-scope sampler variable as argument,
7180           // get the integer literal.
7181           // Do not diagnose if the file-scope variable does not have initializer
7182           // since this has already been diagnosed when parsing the variable
7183           // declaration.
7184           if (!Var->getInit() || !isa<ImplicitCastExpr>(Var->getInit()))
7185             break;
7186           Init = cast<ImplicitCastExpr>(const_cast<Expr*>(
7187             Var->getInit()))->getSubExpr();
7188           SourceType = Init->getType();
7189         }
7190       } else {
7191         // Case 2
7192         // Check initializer is 32 bit integer constant.
7193         // If the initializer is taken from global variable, do not diagnose since
7194         // this has already been done when parsing the variable declaration.
7195         if (!Init->isConstantInitializer(S.Context, false))
7196           break;
7197
7198         if (!SourceType->isIntegerType() ||
7199             32 != S.Context.getIntWidth(SourceType)) {
7200           S.Diag(Kind.getLocation(), diag::err_sampler_initializer_not_integer)
7201             << SourceType;
7202           break;
7203         }
7204
7205         llvm::APSInt Result;
7206         Init->EvaluateAsInt(Result, S.Context);
7207         const uint64_t SamplerValue = Result.getLimitedValue();
7208         // 32-bit value of sampler's initializer is interpreted as
7209         // bit-field with the following structure:
7210         // |unspecified|Filter|Addressing Mode| Normalized Coords|
7211         // |31        6|5    4|3             1|                 0|
7212         // This structure corresponds to enum values of sampler properties
7213         // defined in SPIR spec v1.2 and also opencl-c.h
7214         unsigned AddressingMode  = (0x0E & SamplerValue) >> 1;
7215         unsigned FilterMode      = (0x30 & SamplerValue) >> 4;
7216         if (FilterMode != 1 && FilterMode != 2)
7217           S.Diag(Kind.getLocation(),
7218                  diag::warn_sampler_initializer_invalid_bits)
7219                  << "Filter Mode";
7220         if (AddressingMode > 4)
7221           S.Diag(Kind.getLocation(),
7222                  diag::warn_sampler_initializer_invalid_bits)
7223                  << "Addressing Mode";
7224       }
7225
7226       // Cases 1a, 2a and 2b
7227       // Insert cast from integer to sampler.
7228       CurInit = S.ImpCastExprToType(Init, S.Context.OCLSamplerTy,
7229                                       CK_IntToOCLSampler);
7230       break;
7231     }
7232     case SK_OCLZeroEvent: {
7233       assert(Step->Type->isEventT() &&
7234              "Event initialization on non-event type.");
7235
7236       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
7237                                     CK_ZeroToOCLEvent,
7238                                     CurInit.get()->getValueKind());
7239       break;
7240     }
7241     case SK_OCLZeroQueue: {
7242       assert(Step->Type->isQueueT() &&
7243              "Event initialization on non queue type.");
7244
7245       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
7246                                     CK_ZeroToOCLQueue,
7247                                     CurInit.get()->getValueKind());
7248       break;
7249     }
7250     }
7251   }
7252
7253   // Diagnose non-fatal problems with the completed initialization.
7254   if (Entity.getKind() == InitializedEntity::EK_Member &&
7255       cast<FieldDecl>(Entity.getDecl())->isBitField())
7256     S.CheckBitFieldInitialization(Kind.getLocation(),
7257                                   cast<FieldDecl>(Entity.getDecl()),
7258                                   CurInit.get());
7259
7260   // Check for std::move on construction.
7261   if (const Expr *E = CurInit.get()) {
7262     CheckMoveOnConstruction(S, E,
7263                             Entity.getKind() == InitializedEntity::EK_Result);
7264   }
7265
7266   return CurInit;
7267 }
7268
7269 /// Somewhere within T there is an uninitialized reference subobject.
7270 /// Dig it out and diagnose it.
7271 static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc,
7272                                            QualType T) {
7273   if (T->isReferenceType()) {
7274     S.Diag(Loc, diag::err_reference_without_init)
7275       << T.getNonReferenceType();
7276     return true;
7277   }
7278
7279   CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
7280   if (!RD || !RD->hasUninitializedReferenceMember())
7281     return false;
7282
7283   for (const auto *FI : RD->fields()) {
7284     if (FI->isUnnamedBitfield())
7285       continue;
7286
7287     if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {
7288       S.Diag(Loc, diag::note_value_initialization_here) << RD;
7289       return true;
7290     }
7291   }
7292
7293   for (const auto &BI : RD->bases()) {
7294     if (DiagnoseUninitializedReference(S, BI.getLocStart(), BI.getType())) {
7295       S.Diag(Loc, diag::note_value_initialization_here) << RD;
7296       return true;
7297     }
7298   }
7299
7300   return false;
7301 }
7302
7303
7304 //===----------------------------------------------------------------------===//
7305 // Diagnose initialization failures
7306 //===----------------------------------------------------------------------===//
7307
7308 /// Emit notes associated with an initialization that failed due to a
7309 /// "simple" conversion failure.
7310 static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity,
7311                                    Expr *op) {
7312   QualType destType = entity.getType();
7313   if (destType.getNonReferenceType()->isObjCObjectPointerType() &&
7314       op->getType()->isObjCObjectPointerType()) {
7315
7316     // Emit a possible note about the conversion failing because the
7317     // operand is a message send with a related result type.
7318     S.EmitRelatedResultTypeNote(op);
7319
7320     // Emit a possible note about a return failing because we're
7321     // expecting a related result type.
7322     if (entity.getKind() == InitializedEntity::EK_Result)
7323       S.EmitRelatedResultTypeNoteForReturn(destType);
7324   }
7325 }
7326
7327 static void diagnoseListInit(Sema &S, const InitializedEntity &Entity,
7328                              InitListExpr *InitList) {
7329   QualType DestType = Entity.getType();
7330
7331   QualType E;
7332   if (S.getLangOpts().CPlusPlus11 && S.isStdInitializerList(DestType, &E)) {
7333     QualType ArrayType = S.Context.getConstantArrayType(
7334         E.withConst(),
7335         llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
7336                     InitList->getNumInits()),
7337         clang::ArrayType::Normal, 0);
7338     InitializedEntity HiddenArray =
7339         InitializedEntity::InitializeTemporary(ArrayType);
7340     return diagnoseListInit(S, HiddenArray, InitList);
7341   }
7342
7343   if (DestType->isReferenceType()) {
7344     // A list-initialization failure for a reference means that we tried to
7345     // create a temporary of the inner type (per [dcl.init.list]p3.6) and the
7346     // inner initialization failed.
7347     QualType T = DestType->getAs<ReferenceType>()->getPointeeType();
7348     diagnoseListInit(S, InitializedEntity::InitializeTemporary(T), InitList);
7349     SourceLocation Loc = InitList->getLocStart();
7350     if (auto *D = Entity.getDecl())
7351       Loc = D->getLocation();
7352     S.Diag(Loc, diag::note_in_reference_temporary_list_initializer) << T;
7353     return;
7354   }
7355
7356   InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
7357                                    /*VerifyOnly=*/false,
7358                                    /*TreatUnavailableAsInvalid=*/false);
7359   assert(DiagnoseInitList.HadError() &&
7360          "Inconsistent init list check result.");
7361 }
7362
7363 bool InitializationSequence::Diagnose(Sema &S,
7364                                       const InitializedEntity &Entity,
7365                                       const InitializationKind &Kind,
7366                                       ArrayRef<Expr *> Args) {
7367   if (!Failed())
7368     return false;
7369
7370   QualType DestType = Entity.getType();
7371   switch (Failure) {
7372   case FK_TooManyInitsForReference:
7373     // FIXME: Customize for the initialized entity?
7374     if (Args.empty()) {
7375       // Dig out the reference subobject which is uninitialized and diagnose it.
7376       // If this is value-initialization, this could be nested some way within
7377       // the target type.
7378       assert(Kind.getKind() == InitializationKind::IK_Value ||
7379              DestType->isReferenceType());
7380       bool Diagnosed =
7381         DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
7382       assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
7383       (void)Diagnosed;
7384     } else  // FIXME: diagnostic below could be better!
7385       S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
7386         << SourceRange(Args.front()->getLocStart(), Args.back()->getLocEnd());
7387     break;
7388
7389   case FK_ArrayNeedsInitList:
7390     S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
7391     break;
7392   case FK_ArrayNeedsInitListOrStringLiteral:
7393     S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
7394     break;
7395   case FK_ArrayNeedsInitListOrWideStringLiteral:
7396     S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
7397     break;
7398   case FK_NarrowStringIntoWideCharArray:
7399     S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
7400     break;
7401   case FK_WideStringIntoCharArray:
7402     S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
7403     break;
7404   case FK_IncompatWideStringIntoWideChar:
7405     S.Diag(Kind.getLocation(),
7406            diag::err_array_init_incompat_wide_string_into_wchar);
7407     break;
7408   case FK_ArrayTypeMismatch:
7409   case FK_NonConstantArrayInit:
7410     S.Diag(Kind.getLocation(),
7411            (Failure == FK_ArrayTypeMismatch
7412               ? diag::err_array_init_different_type
7413               : diag::err_array_init_non_constant_array))
7414       << DestType.getNonReferenceType()
7415       << Args[0]->getType()
7416       << Args[0]->getSourceRange();
7417     break;
7418
7419   case FK_VariableLengthArrayHasInitializer:
7420     S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
7421       << Args[0]->getSourceRange();
7422     break;
7423
7424   case FK_AddressOfOverloadFailed: {
7425     DeclAccessPair Found;
7426     S.ResolveAddressOfOverloadedFunction(Args[0],
7427                                          DestType.getNonReferenceType(),
7428                                          true,
7429                                          Found);
7430     break;
7431   }
7432
7433   case FK_AddressOfUnaddressableFunction: {
7434     auto *FD = cast<FunctionDecl>(cast<DeclRefExpr>(Args[0])->getDecl());
7435     S.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
7436                                         Args[0]->getLocStart());
7437     break;
7438   }
7439
7440   case FK_ReferenceInitOverloadFailed:
7441   case FK_UserConversionOverloadFailed:
7442     switch (FailedOverloadResult) {
7443     case OR_Ambiguous:
7444       if (Failure == FK_UserConversionOverloadFailed)
7445         S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
7446           << Args[0]->getType() << DestType
7447           << Args[0]->getSourceRange();
7448       else
7449         S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
7450           << DestType << Args[0]->getType()
7451           << Args[0]->getSourceRange();
7452
7453       FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
7454       break;
7455
7456     case OR_No_Viable_Function:
7457       if (!S.RequireCompleteType(Kind.getLocation(),
7458                                  DestType.getNonReferenceType(),
7459                           diag::err_typecheck_nonviable_condition_incomplete,
7460                                Args[0]->getType(), Args[0]->getSourceRange()))
7461         S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
7462           << (Entity.getKind() == InitializedEntity::EK_Result)
7463           << Args[0]->getType() << Args[0]->getSourceRange()
7464           << DestType.getNonReferenceType();
7465
7466       FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
7467       break;
7468
7469     case OR_Deleted: {
7470       S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
7471         << Args[0]->getType() << DestType.getNonReferenceType()
7472         << Args[0]->getSourceRange();
7473       OverloadCandidateSet::iterator Best;
7474       OverloadingResult Ovl
7475         = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best,
7476                                                 true);
7477       if (Ovl == OR_Deleted) {
7478         S.NoteDeletedFunction(Best->Function);
7479       } else {
7480         llvm_unreachable("Inconsistent overload resolution?");
7481       }
7482       break;
7483     }
7484
7485     case OR_Success:
7486       llvm_unreachable("Conversion did not fail!");
7487     }
7488     break;
7489
7490   case FK_NonConstLValueReferenceBindingToTemporary:
7491     if (isa<InitListExpr>(Args[0])) {
7492       S.Diag(Kind.getLocation(),
7493              diag::err_lvalue_reference_bind_to_initlist)
7494       << DestType.getNonReferenceType().isVolatileQualified()
7495       << DestType.getNonReferenceType()
7496       << Args[0]->getSourceRange();
7497       break;
7498     }
7499     // Intentional fallthrough
7500
7501   case FK_NonConstLValueReferenceBindingToUnrelated:
7502     S.Diag(Kind.getLocation(),
7503            Failure == FK_NonConstLValueReferenceBindingToTemporary
7504              ? diag::err_lvalue_reference_bind_to_temporary
7505              : diag::err_lvalue_reference_bind_to_unrelated)
7506       << DestType.getNonReferenceType().isVolatileQualified()
7507       << DestType.getNonReferenceType()
7508       << Args[0]->getType()
7509       << Args[0]->getSourceRange();
7510     break;
7511
7512   case FK_NonConstLValueReferenceBindingToBitfield: {
7513     // We don't necessarily have an unambiguous source bit-field.
7514     FieldDecl *BitField = Args[0]->getSourceBitField();
7515     S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
7516       << DestType.isVolatileQualified()
7517       << (BitField ? BitField->getDeclName() : DeclarationName())
7518       << (BitField != nullptr)
7519       << Args[0]->getSourceRange();
7520     if (BitField)
7521       S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
7522     break;
7523   }
7524
7525   case FK_NonConstLValueReferenceBindingToVectorElement:
7526     S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
7527       << DestType.isVolatileQualified()
7528       << Args[0]->getSourceRange();
7529     break;
7530
7531   case FK_RValueReferenceBindingToLValue:
7532     S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
7533       << DestType.getNonReferenceType() << Args[0]->getType()
7534       << Args[0]->getSourceRange();
7535     break;
7536
7537   case FK_ReferenceInitDropsQualifiers: {
7538     QualType SourceType = Args[0]->getType();
7539     QualType NonRefType = DestType.getNonReferenceType();
7540     Qualifiers DroppedQualifiers =
7541         SourceType.getQualifiers() - NonRefType.getQualifiers();
7542
7543     S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
7544       << SourceType
7545       << NonRefType
7546       << DroppedQualifiers.getCVRQualifiers()
7547       << Args[0]->getSourceRange();
7548     break;
7549   }
7550
7551   case FK_ReferenceInitFailed:
7552     S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
7553       << DestType.getNonReferenceType()
7554       << Args[0]->isLValue()
7555       << Args[0]->getType()
7556       << Args[0]->getSourceRange();
7557     emitBadConversionNotes(S, Entity, Args[0]);
7558     break;
7559
7560   case FK_ConversionFailed: {
7561     QualType FromType = Args[0]->getType();
7562     PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
7563       << (int)Entity.getKind()
7564       << DestType
7565       << Args[0]->isLValue()
7566       << FromType
7567       << Args[0]->getSourceRange();
7568     S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
7569     S.Diag(Kind.getLocation(), PDiag);
7570     emitBadConversionNotes(S, Entity, Args[0]);
7571     break;
7572   }
7573
7574   case FK_ConversionFromPropertyFailed:
7575     // No-op. This error has already been reported.
7576     break;
7577
7578   case FK_TooManyInitsForScalar: {
7579     SourceRange R;
7580
7581     auto *InitList = dyn_cast<InitListExpr>(Args[0]);
7582     if (InitList && InitList->getNumInits() >= 1) {
7583       R = SourceRange(InitList->getInit(0)->getLocEnd(), InitList->getLocEnd());
7584     } else {
7585       assert(Args.size() > 1 && "Expected multiple initializers!");
7586       R = SourceRange(Args.front()->getLocEnd(), Args.back()->getLocEnd());
7587     }
7588
7589     R.setBegin(S.getLocForEndOfToken(R.getBegin()));
7590     if (Kind.isCStyleOrFunctionalCast())
7591       S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
7592         << R;
7593     else
7594       S.Diag(Kind.getLocation(), diag::err_excess_initializers)
7595         << /*scalar=*/2 << R;
7596     break;
7597   }
7598
7599   case FK_ReferenceBindingToInitList:
7600     S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
7601       << DestType.getNonReferenceType() << Args[0]->getSourceRange();
7602     break;
7603
7604   case FK_InitListBadDestinationType:
7605     S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
7606       << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
7607     break;
7608
7609   case FK_ListConstructorOverloadFailed:
7610   case FK_ConstructorOverloadFailed: {
7611     SourceRange ArgsRange;
7612     if (Args.size())
7613       ArgsRange = SourceRange(Args.front()->getLocStart(),
7614                               Args.back()->getLocEnd());
7615
7616     if (Failure == FK_ListConstructorOverloadFailed) {
7617       assert(Args.size() == 1 &&
7618              "List construction from other than 1 argument.");
7619       InitListExpr *InitList = cast<InitListExpr>(Args[0]);
7620       Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
7621     }
7622
7623     // FIXME: Using "DestType" for the entity we're printing is probably
7624     // bad.
7625     switch (FailedOverloadResult) {
7626       case OR_Ambiguous:
7627         S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
7628           << DestType << ArgsRange;
7629         FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
7630         break;
7631
7632       case OR_No_Viable_Function:
7633         if (Kind.getKind() == InitializationKind::IK_Default &&
7634             (Entity.getKind() == InitializedEntity::EK_Base ||
7635              Entity.getKind() == InitializedEntity::EK_Member) &&
7636             isa<CXXConstructorDecl>(S.CurContext)) {
7637           // This is implicit default initialization of a member or
7638           // base within a constructor. If no viable function was
7639           // found, notify the user that they need to explicitly
7640           // initialize this base/member.
7641           CXXConstructorDecl *Constructor
7642             = cast<CXXConstructorDecl>(S.CurContext);
7643           const CXXRecordDecl *InheritedFrom = nullptr;
7644           if (auto Inherited = Constructor->getInheritedConstructor())
7645             InheritedFrom = Inherited.getShadowDecl()->getNominatedBaseClass();
7646           if (Entity.getKind() == InitializedEntity::EK_Base) {
7647             S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
7648               << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
7649               << S.Context.getTypeDeclType(Constructor->getParent())
7650               << /*base=*/0
7651               << Entity.getType()
7652               << InheritedFrom;
7653
7654             RecordDecl *BaseDecl
7655               = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
7656                                                                   ->getDecl();
7657             S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
7658               << S.Context.getTagDeclType(BaseDecl);
7659           } else {
7660             S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
7661               << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
7662               << S.Context.getTypeDeclType(Constructor->getParent())
7663               << /*member=*/1
7664               << Entity.getName()
7665               << InheritedFrom;
7666             S.Diag(Entity.getDecl()->getLocation(),
7667                    diag::note_member_declared_at);
7668
7669             if (const RecordType *Record
7670                                  = Entity.getType()->getAs<RecordType>())
7671               S.Diag(Record->getDecl()->getLocation(),
7672                      diag::note_previous_decl)
7673                 << S.Context.getTagDeclType(Record->getDecl());
7674           }
7675           break;
7676         }
7677
7678         S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
7679           << DestType << ArgsRange;
7680         FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
7681         break;
7682
7683       case OR_Deleted: {
7684         OverloadCandidateSet::iterator Best;
7685         OverloadingResult Ovl
7686           = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
7687         if (Ovl != OR_Deleted) {
7688           S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
7689             << true << DestType << ArgsRange;
7690           llvm_unreachable("Inconsistent overload resolution?");
7691           break;
7692         }
7693
7694         // If this is a defaulted or implicitly-declared function, then
7695         // it was implicitly deleted. Make it clear that the deletion was
7696         // implicit.
7697         if (S.isImplicitlyDeleted(Best->Function))
7698           S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
7699             << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
7700             << DestType << ArgsRange;
7701         else
7702           S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
7703             << true << DestType << ArgsRange;
7704
7705         S.NoteDeletedFunction(Best->Function);
7706         break;
7707       }
7708
7709       case OR_Success:
7710         llvm_unreachable("Conversion did not fail!");
7711     }
7712   }
7713   break;
7714
7715   case FK_DefaultInitOfConst:
7716     if (Entity.getKind() == InitializedEntity::EK_Member &&
7717         isa<CXXConstructorDecl>(S.CurContext)) {
7718       // This is implicit default-initialization of a const member in
7719       // a constructor. Complain that it needs to be explicitly
7720       // initialized.
7721       CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
7722       S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
7723         << (Constructor->getInheritedConstructor() ? 2 :
7724             Constructor->isImplicit() ? 1 : 0)
7725         << S.Context.getTypeDeclType(Constructor->getParent())
7726         << /*const=*/1
7727         << Entity.getName();
7728       S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
7729         << Entity.getName();
7730     } else {
7731       S.Diag(Kind.getLocation(), diag::err_default_init_const)
7732           << DestType << (bool)DestType->getAs<RecordType>();
7733     }
7734     break;
7735
7736   case FK_Incomplete:
7737     S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
7738                           diag::err_init_incomplete_type);
7739     break;
7740
7741   case FK_ListInitializationFailed: {
7742     // Run the init list checker again to emit diagnostics.
7743     InitListExpr *InitList = cast<InitListExpr>(Args[0]);
7744     diagnoseListInit(S, Entity, InitList);
7745     break;
7746   }
7747
7748   case FK_PlaceholderType: {
7749     // FIXME: Already diagnosed!
7750     break;
7751   }
7752
7753   case FK_ExplicitConstructor: {
7754     S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
7755       << Args[0]->getSourceRange();
7756     OverloadCandidateSet::iterator Best;
7757     OverloadingResult Ovl
7758       = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
7759     (void)Ovl;
7760     assert(Ovl == OR_Success && "Inconsistent overload resolution");
7761     CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
7762     S.Diag(CtorDecl->getLocation(), diag::note_constructor_declared_here);
7763     break;
7764   }
7765   }
7766
7767   PrintInitLocationNote(S, Entity);
7768   return true;
7769 }
7770
7771 void InitializationSequence::dump(raw_ostream &OS) const {
7772   switch (SequenceKind) {
7773   case FailedSequence: {
7774     OS << "Failed sequence: ";
7775     switch (Failure) {
7776     case FK_TooManyInitsForReference:
7777       OS << "too many initializers for reference";
7778       break;
7779
7780     case FK_ArrayNeedsInitList:
7781       OS << "array requires initializer list";
7782       break;
7783
7784     case FK_AddressOfUnaddressableFunction:
7785       OS << "address of unaddressable function was taken";
7786       break;
7787
7788     case FK_ArrayNeedsInitListOrStringLiteral:
7789       OS << "array requires initializer list or string literal";
7790       break;
7791
7792     case FK_ArrayNeedsInitListOrWideStringLiteral:
7793       OS << "array requires initializer list or wide string literal";
7794       break;
7795
7796     case FK_NarrowStringIntoWideCharArray:
7797       OS << "narrow string into wide char array";
7798       break;
7799
7800     case FK_WideStringIntoCharArray:
7801       OS << "wide string into char array";
7802       break;
7803
7804     case FK_IncompatWideStringIntoWideChar:
7805       OS << "incompatible wide string into wide char array";
7806       break;
7807
7808     case FK_ArrayTypeMismatch:
7809       OS << "array type mismatch";
7810       break;
7811
7812     case FK_NonConstantArrayInit:
7813       OS << "non-constant array initializer";
7814       break;
7815
7816     case FK_AddressOfOverloadFailed:
7817       OS << "address of overloaded function failed";
7818       break;
7819
7820     case FK_ReferenceInitOverloadFailed:
7821       OS << "overload resolution for reference initialization failed";
7822       break;
7823
7824     case FK_NonConstLValueReferenceBindingToTemporary:
7825       OS << "non-const lvalue reference bound to temporary";
7826       break;
7827
7828     case FK_NonConstLValueReferenceBindingToBitfield:
7829       OS << "non-const lvalue reference bound to bit-field";
7830       break;
7831
7832     case FK_NonConstLValueReferenceBindingToVectorElement:
7833       OS << "non-const lvalue reference bound to vector element";
7834       break;
7835
7836     case FK_NonConstLValueReferenceBindingToUnrelated:
7837       OS << "non-const lvalue reference bound to unrelated type";
7838       break;
7839
7840     case FK_RValueReferenceBindingToLValue:
7841       OS << "rvalue reference bound to an lvalue";
7842       break;
7843
7844     case FK_ReferenceInitDropsQualifiers:
7845       OS << "reference initialization drops qualifiers";
7846       break;
7847
7848     case FK_ReferenceInitFailed:
7849       OS << "reference initialization failed";
7850       break;
7851
7852     case FK_ConversionFailed:
7853       OS << "conversion failed";
7854       break;
7855
7856     case FK_ConversionFromPropertyFailed:
7857       OS << "conversion from property failed";
7858       break;
7859
7860     case FK_TooManyInitsForScalar:
7861       OS << "too many initializers for scalar";
7862       break;
7863
7864     case FK_ReferenceBindingToInitList:
7865       OS << "referencing binding to initializer list";
7866       break;
7867
7868     case FK_InitListBadDestinationType:
7869       OS << "initializer list for non-aggregate, non-scalar type";
7870       break;
7871
7872     case FK_UserConversionOverloadFailed:
7873       OS << "overloading failed for user-defined conversion";
7874       break;
7875
7876     case FK_ConstructorOverloadFailed:
7877       OS << "constructor overloading failed";
7878       break;
7879
7880     case FK_DefaultInitOfConst:
7881       OS << "default initialization of a const variable";
7882       break;
7883
7884     case FK_Incomplete:
7885       OS << "initialization of incomplete type";
7886       break;
7887
7888     case FK_ListInitializationFailed:
7889       OS << "list initialization checker failure";
7890       break;
7891
7892     case FK_VariableLengthArrayHasInitializer:
7893       OS << "variable length array has an initializer";
7894       break;
7895
7896     case FK_PlaceholderType:
7897       OS << "initializer expression isn't contextually valid";
7898       break;
7899
7900     case FK_ListConstructorOverloadFailed:
7901       OS << "list constructor overloading failed";
7902       break;
7903
7904     case FK_ExplicitConstructor:
7905       OS << "list copy initialization chose explicit constructor";
7906       break;
7907     }
7908     OS << '\n';
7909     return;
7910   }
7911
7912   case DependentSequence:
7913     OS << "Dependent sequence\n";
7914     return;
7915
7916   case NormalSequence:
7917     OS << "Normal sequence: ";
7918     break;
7919   }
7920
7921   for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
7922     if (S != step_begin()) {
7923       OS << " -> ";
7924     }
7925
7926     switch (S->Kind) {
7927     case SK_ResolveAddressOfOverloadedFunction:
7928       OS << "resolve address of overloaded function";
7929       break;
7930
7931     case SK_CastDerivedToBaseRValue:
7932       OS << "derived-to-base (rvalue)";
7933       break;
7934
7935     case SK_CastDerivedToBaseXValue:
7936       OS << "derived-to-base (xvalue)";
7937       break;
7938
7939     case SK_CastDerivedToBaseLValue:
7940       OS << "derived-to-base (lvalue)";
7941       break;
7942
7943     case SK_BindReference:
7944       OS << "bind reference to lvalue";
7945       break;
7946
7947     case SK_BindReferenceToTemporary:
7948       OS << "bind reference to a temporary";
7949       break;
7950
7951     case SK_FinalCopy:
7952       OS << "final copy in class direct-initialization";
7953       break;
7954
7955     case SK_ExtraneousCopyToTemporary:
7956       OS << "extraneous C++03 copy to temporary";
7957       break;
7958
7959     case SK_UserConversion:
7960       OS << "user-defined conversion via " << *S->Function.Function;
7961       break;
7962
7963     case SK_QualificationConversionRValue:
7964       OS << "qualification conversion (rvalue)";
7965       break;
7966
7967     case SK_QualificationConversionXValue:
7968       OS << "qualification conversion (xvalue)";
7969       break;
7970
7971     case SK_QualificationConversionLValue:
7972       OS << "qualification conversion (lvalue)";
7973       break;
7974
7975     case SK_AtomicConversion:
7976       OS << "non-atomic-to-atomic conversion";
7977       break;
7978
7979     case SK_LValueToRValue:
7980       OS << "load (lvalue to rvalue)";
7981       break;
7982
7983     case SK_ConversionSequence:
7984       OS << "implicit conversion sequence (";
7985       S->ICS->dump(); // FIXME: use OS
7986       OS << ")";
7987       break;
7988
7989     case SK_ConversionSequenceNoNarrowing:
7990       OS << "implicit conversion sequence with narrowing prohibited (";
7991       S->ICS->dump(); // FIXME: use OS
7992       OS << ")";
7993       break;
7994
7995     case SK_ListInitialization:
7996       OS << "list aggregate initialization";
7997       break;
7998
7999     case SK_UnwrapInitList:
8000       OS << "unwrap reference initializer list";
8001       break;
8002
8003     case SK_RewrapInitList:
8004       OS << "rewrap reference initializer list";
8005       break;
8006
8007     case SK_ConstructorInitialization:
8008       OS << "constructor initialization";
8009       break;
8010
8011     case SK_ConstructorInitializationFromList:
8012       OS << "list initialization via constructor";
8013       break;
8014
8015     case SK_ZeroInitialization:
8016       OS << "zero initialization";
8017       break;
8018
8019     case SK_CAssignment:
8020       OS << "C assignment";
8021       break;
8022
8023     case SK_StringInit:
8024       OS << "string initialization";
8025       break;
8026
8027     case SK_ObjCObjectConversion:
8028       OS << "Objective-C object conversion";
8029       break;
8030
8031     case SK_ArrayLoopIndex:
8032       OS << "indexing for array initialization loop";
8033       break;
8034
8035     case SK_ArrayLoopInit:
8036       OS << "array initialization loop";
8037       break;
8038
8039     case SK_ArrayInit:
8040       OS << "array initialization";
8041       break;
8042
8043     case SK_GNUArrayInit:
8044       OS << "array initialization (GNU extension)";
8045       break;
8046
8047     case SK_ParenthesizedArrayInit:
8048       OS << "parenthesized array initialization";
8049       break;
8050
8051     case SK_PassByIndirectCopyRestore:
8052       OS << "pass by indirect copy and restore";
8053       break;
8054
8055     case SK_PassByIndirectRestore:
8056       OS << "pass by indirect restore";
8057       break;
8058
8059     case SK_ProduceObjCObject:
8060       OS << "Objective-C object retension";
8061       break;
8062
8063     case SK_StdInitializerList:
8064       OS << "std::initializer_list from initializer list";
8065       break;
8066
8067     case SK_StdInitializerListConstructorCall:
8068       OS << "list initialization from std::initializer_list";
8069       break;
8070
8071     case SK_OCLSamplerInit:
8072       OS << "OpenCL sampler_t from integer constant";
8073       break;
8074
8075     case SK_OCLZeroEvent:
8076       OS << "OpenCL event_t from zero";
8077       break;
8078
8079     case SK_OCLZeroQueue:
8080       OS << "OpenCL queue_t from zero";
8081       break;
8082     }
8083
8084     OS << " [" << S->Type.getAsString() << ']';
8085   }
8086
8087   OS << '\n';
8088 }
8089
8090 void InitializationSequence::dump() const {
8091   dump(llvm::errs());
8092 }
8093
8094 static void DiagnoseNarrowingInInitList(Sema &S,
8095                                         const ImplicitConversionSequence &ICS,
8096                                         QualType PreNarrowingType,
8097                                         QualType EntityType,
8098                                         const Expr *PostInit) {
8099   const StandardConversionSequence *SCS = nullptr;
8100   switch (ICS.getKind()) {
8101   case ImplicitConversionSequence::StandardConversion:
8102     SCS = &ICS.Standard;
8103     break;
8104   case ImplicitConversionSequence::UserDefinedConversion:
8105     SCS = &ICS.UserDefined.After;
8106     break;
8107   case ImplicitConversionSequence::AmbiguousConversion:
8108   case ImplicitConversionSequence::EllipsisConversion:
8109   case ImplicitConversionSequence::BadConversion:
8110     return;
8111   }
8112
8113   // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
8114   APValue ConstantValue;
8115   QualType ConstantType;
8116   switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
8117                                 ConstantType)) {
8118   case NK_Not_Narrowing:
8119   case NK_Dependent_Narrowing:
8120     // No narrowing occurred.
8121     return;
8122
8123   case NK_Type_Narrowing:
8124     // This was a floating-to-integer conversion, which is always considered a
8125     // narrowing conversion even if the value is a constant and can be
8126     // represented exactly as an integer.
8127     S.Diag(PostInit->getLocStart(),
8128            (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
8129                ? diag::warn_init_list_type_narrowing
8130                : diag::ext_init_list_type_narrowing)
8131       << PostInit->getSourceRange()
8132       << PreNarrowingType.getLocalUnqualifiedType()
8133       << EntityType.getLocalUnqualifiedType();
8134     break;
8135
8136   case NK_Constant_Narrowing:
8137     // A constant value was narrowed.
8138     S.Diag(PostInit->getLocStart(),
8139            (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
8140                ? diag::warn_init_list_constant_narrowing
8141                : diag::ext_init_list_constant_narrowing)
8142       << PostInit->getSourceRange()
8143       << ConstantValue.getAsString(S.getASTContext(), ConstantType)
8144       << EntityType.getLocalUnqualifiedType();
8145     break;
8146
8147   case NK_Variable_Narrowing:
8148     // A variable's value may have been narrowed.
8149     S.Diag(PostInit->getLocStart(),
8150            (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
8151                ? diag::warn_init_list_variable_narrowing
8152                : diag::ext_init_list_variable_narrowing)
8153       << PostInit->getSourceRange()
8154       << PreNarrowingType.getLocalUnqualifiedType()
8155       << EntityType.getLocalUnqualifiedType();
8156     break;
8157   }
8158
8159   SmallString<128> StaticCast;
8160   llvm::raw_svector_ostream OS(StaticCast);
8161   OS << "static_cast<";
8162   if (const TypedefType *TT = EntityType->getAs<TypedefType>()) {
8163     // It's important to use the typedef's name if there is one so that the
8164     // fixit doesn't break code using types like int64_t.
8165     //
8166     // FIXME: This will break if the typedef requires qualification.  But
8167     // getQualifiedNameAsString() includes non-machine-parsable components.
8168     OS << *TT->getDecl();
8169   } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>())
8170     OS << BT->getName(S.getLangOpts());
8171   else {
8172     // Oops, we didn't find the actual type of the variable.  Don't emit a fixit
8173     // with a broken cast.
8174     return;
8175   }
8176   OS << ">(";
8177   S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_silence)
8178       << PostInit->getSourceRange()
8179       << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str())
8180       << FixItHint::CreateInsertion(
8181              S.getLocForEndOfToken(PostInit->getLocEnd()), ")");
8182 }
8183
8184 //===----------------------------------------------------------------------===//
8185 // Initialization helper functions
8186 //===----------------------------------------------------------------------===//
8187 bool
8188 Sema::CanPerformCopyInitialization(const InitializedEntity &Entity,
8189                                    ExprResult Init) {
8190   if (Init.isInvalid())
8191     return false;
8192
8193   Expr *InitE = Init.get();
8194   assert(InitE && "No initialization expression");
8195
8196   InitializationKind Kind
8197     = InitializationKind::CreateCopy(InitE->getLocStart(), SourceLocation());
8198   InitializationSequence Seq(*this, Entity, Kind, InitE);
8199   return !Seq.Failed();
8200 }
8201
8202 ExprResult
8203 Sema::PerformCopyInitialization(const InitializedEntity &Entity,
8204                                 SourceLocation EqualLoc,
8205                                 ExprResult Init,
8206                                 bool TopLevelOfInitList,
8207                                 bool AllowExplicit) {
8208   if (Init.isInvalid())
8209     return ExprError();
8210
8211   Expr *InitE = Init.get();
8212   assert(InitE && "No initialization expression?");
8213
8214   if (EqualLoc.isInvalid())
8215     EqualLoc = InitE->getLocStart();
8216
8217   InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
8218                                                            EqualLoc,
8219                                                            AllowExplicit);
8220   InitializationSequence Seq(*this, Entity, Kind, InitE, TopLevelOfInitList);
8221
8222   ExprResult Result = Seq.Perform(*this, Entity, Kind, InitE);
8223
8224   return Result;
8225 }