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

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