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

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