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