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