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. The main entry
  11 // point is Sema::CheckInitList(), but all of the work is performed
  12 // within the InitListChecker class.
  13 //
  14 // This file also implements Sema::CheckInitializerTypes.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #include "SemaInit.h"
  19 #include "Lookup.h"
  20 #include "Sema.h"
  21 #include "clang/Parse/Designator.h"
  22 #include "clang/AST/ASTContext.h"
  23 #include "clang/AST/ExprCXX.h"
  24 #include "clang/AST/ExprObjC.h"
  25 #include "clang/AST/TypeLoc.h"
  26 #include "llvm/Support/ErrorHandling.h"
  27 #include <map>
  28 using namespace clang;
  29
  30 //===----------------------------------------------------------------------===//
  31 // Sema Initialization Checking
  32 //===----------------------------------------------------------------------===//
  33
  34 static Expr *IsStringInit(Expr *Init, QualType DeclType, ASTContext &Context) {
  35   const ArrayType *AT = Context.getAsArrayType(DeclType);
  36   if (!AT) return 0;
  37
  38   if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
  39     return 0;
  40
  41   // See if this is a string literal or @encode.
  42   Init = Init->IgnoreParens();
  43
  44   // Handle @encode, which is a narrow string.
  45   if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
  46     return Init;
  47
  48   // Otherwise we can only handle string literals.
  49   StringLiteral *SL = dyn_cast<StringLiteral>(Init);
  50   if (SL == 0) return 0;
  51
  52   QualType ElemTy = Context.getCanonicalType(AT->getElementType());
  53   // char array can be initialized with a narrow string.
  54   // Only allow char x[] = "foo";  not char x[] = L"foo";
  55   if (!SL->isWide())
  56     return ElemTy->isCharType() ? Init : 0;
  57
  58   // wchar_t array can be initialized with a wide string: C99 6.7.8p15 (with
  59   // correction from DR343): "An array with element type compatible with a
  60   // qualified or unqualified version of wchar_t may be initialized by a wide
  61   // string literal, optionally enclosed in braces."
  62   if (Context.typesAreCompatible(Context.getWCharType(),
  63                                  ElemTy.getUnqualifiedType()))
  64     return Init;
  65
  66   return 0;
  67 }
  68
  69 static void CheckStringInit(Expr *Str, QualType &DeclT, Sema &S) {
  70   // Get the length of the string as parsed.
  71   uint64_t StrLength =
  72     cast<ConstantArrayType>(Str->getType())->getSize().getZExtValue();
  73
  74
  75   const ArrayType *AT = S.Context.getAsArrayType(DeclT);
  76   if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
  77     // C99 6.7.8p14. We have an array of character type with unknown size
  78     // being initialized to a string literal.
  79     llvm::APSInt ConstVal(32);
  80     ConstVal = StrLength;
  81     // Return a new array type (C99 6.7.8p22).
  82     DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
  83                                            ConstVal,
  84                                            ArrayType::Normal, 0);
  85     return;
  86   }
  87
  88   const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
  89
  90   // C99 6.7.8p14. We have an array of character type with known size.  However,
  91   // the size may be smaller or larger than the string we are initializing.
  92   // FIXME: Avoid truncation for 64-bit length strings.
  93   if (StrLength-1 > CAT->getSize().getZExtValue())
  94     S.Diag(Str->getSourceRange().getBegin(),
  95            diag::warn_initializer_string_for_char_array_too_long)
  96       << Str->getSourceRange();
  97
  98   // Set the type to the actual size that we are initializing.  If we have
  99   // something like:
 100   //   char x[1] = "foo";
 101   // then this will set the string literal's type to char[1].
 102   Str->setType(DeclT);
 103 }
 104
 105 //===----------------------------------------------------------------------===//
 106 // Semantic checking for initializer lists.
 107 //===----------------------------------------------------------------------===//
 108
 109 /// @brief Semantic checking for initializer lists.
 110 ///
 111 /// The InitListChecker class contains a set of routines that each
 112 /// handle the initialization of a certain kind of entity, e.g.,
 113 /// arrays, vectors, struct/union types, scalars, etc. The
 114 /// InitListChecker itself performs a recursive walk of the subobject
 115 /// structure of the type to be initialized, while stepping through
 116 /// the initializer list one element at a time. The IList and Index
 117 /// parameters to each of the Check* routines contain the active
 118 /// (syntactic) initializer list and the index into that initializer
 119 /// list that represents the current initializer. Each routine is
 120 /// responsible for moving that Index forward as it consumes elements.
 121 ///
 122 /// Each Check* routine also has a StructuredList/StructuredIndex
 123 /// arguments, which contains the current the "structured" (semantic)
 124 /// initializer list and the index into that initializer list where we
 125 /// are copying initializers as we map them over to the semantic
 126 /// list. Once we have completed our recursive walk of the subobject
 127 /// structure, we will have constructed a full semantic initializer
 128 /// list.
 129 ///
 130 /// C99 designators cause changes in the initializer list traversal,
 131 /// because they make the initialization "jump" into a specific
 132 /// subobject and then continue the initialization from that
 133 /// point. CheckDesignatedInitializer() recursively steps into the
 134 /// designated subobject and manages backing out the recursion to
 135 /// initialize the subobjects after the one designated.
 136 namespace {
 137 class InitListChecker {
 138   Sema &SemaRef;
 139   bool hadError;
 140   std::map<InitListExpr *, InitListExpr *> SyntacticToSemantic;
 141   InitListExpr *FullyStructuredList;
 142
 143   void CheckImplicitInitList(const InitializedEntity &Entity,
 144                              InitListExpr *ParentIList, QualType T,
 145                              unsigned &Index, InitListExpr *StructuredList,
 146                              unsigned &StructuredIndex,
 147                              bool TopLevelObject = false);
 148   void CheckExplicitInitList(const InitializedEntity &Entity,
 149                              InitListExpr *IList, QualType &T,
 150                              unsigned &Index, InitListExpr *StructuredList,
 151                              unsigned &StructuredIndex,
 152                              bool TopLevelObject = false);
 153   void CheckListElementTypes(const InitializedEntity &Entity,
 154                              InitListExpr *IList, QualType &DeclType,
 155                              bool SubobjectIsDesignatorContext,
 156                              unsigned &Index,
 157                              InitListExpr *StructuredList,
 158                              unsigned &StructuredIndex,
 159                              bool TopLevelObject = false);
 160   void CheckSubElementType(const InitializedEntity &Entity,
 161                            InitListExpr *IList, QualType ElemType,
 162                            unsigned &Index,
 163                            InitListExpr *StructuredList,
 164                            unsigned &StructuredIndex);
 165   void CheckScalarType(const InitializedEntity &Entity,
 166                        InitListExpr *IList, QualType DeclType,
 167                        unsigned &Index,
 168                        InitListExpr *StructuredList,
 169                        unsigned &StructuredIndex);
 170   void CheckReferenceType(const InitializedEntity &Entity,
 171                           InitListExpr *IList, QualType DeclType,
 172                           unsigned &Index,
 173                           InitListExpr *StructuredList,
 174                           unsigned &StructuredIndex);
 175   void CheckVectorType(const InitializedEntity &Entity,
 176                        InitListExpr *IList, QualType DeclType, unsigned &Index,
 177                        InitListExpr *StructuredList,
 178                        unsigned &StructuredIndex);
 179   void CheckStructUnionTypes(const InitializedEntity &Entity,
 180                              InitListExpr *IList, QualType DeclType,
 181                              RecordDecl::field_iterator Field,
 182                              bool SubobjectIsDesignatorContext, unsigned &Index,
 183                              InitListExpr *StructuredList,
 184                              unsigned &StructuredIndex,
 185                              bool TopLevelObject = false);
 186   void CheckArrayType(const InitializedEntity &Entity,
 187                       InitListExpr *IList, QualType &DeclType,
 188                       llvm::APSInt elementIndex,
 189                       bool SubobjectIsDesignatorContext, unsigned &Index,
 190                       InitListExpr *StructuredList,
 191                       unsigned &StructuredIndex);
 192   bool CheckDesignatedInitializer(const InitializedEntity &Entity,
 193                                   InitListExpr *IList, DesignatedInitExpr *DIE,
 194                                   unsigned DesigIdx,
 195                                   QualType &CurrentObjectType,
 196                                   RecordDecl::field_iterator *NextField,
 197                                   llvm::APSInt *NextElementIndex,
 198                                   unsigned &Index,
 199                                   InitListExpr *StructuredList,
 200                                   unsigned &StructuredIndex,
 201                                   bool FinishSubobjectInit,
 202                                   bool TopLevelObject);
 203   InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
 204                                            QualType CurrentObjectType,
 205                                            InitListExpr *StructuredList,
 206                                            unsigned StructuredIndex,
 207                                            SourceRange InitRange);
 208   void UpdateStructuredListElement(InitListExpr *StructuredList,
 209                                    unsigned &StructuredIndex,
 210                                    Expr *expr);
 211   int numArrayElements(QualType DeclType);
 212   int numStructUnionElements(QualType DeclType);
 213
 214   void FillInValueInitForField(unsigned Init, FieldDecl *Field,
 215                                const InitializedEntity &ParentEntity,
 216                                InitListExpr *ILE, bool &RequiresSecondPass);
 217   void FillInValueInitializations(const InitializedEntity &Entity,
 218                                   InitListExpr *ILE, bool &RequiresSecondPass);
 219 public:
 220   InitListChecker(Sema &S, const InitializedEntity &Entity,
 221                   InitListExpr *IL, QualType &T);
 222   bool HadError() { return hadError; }
 223
 224   // @brief Retrieves the fully-structured initializer list used for
 225   // semantic analysis and code generation.
 226   InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
 227 };
 228 } // end anonymous namespace
 229
 230 void InitListChecker::FillInValueInitForField(unsigned Init, FieldDecl *Field,
 231                                         const InitializedEntity &ParentEntity,
 232                                               InitListExpr *ILE,
 233                                               bool &RequiresSecondPass) {
 234   SourceLocation Loc = ILE->getSourceRange().getBegin();
 235   unsigned NumInits = ILE->getNumInits();
 236   InitializedEntity MemberEntity
 237     = InitializedEntity::InitializeMember(Field, &ParentEntity);
 238   if (Init >= NumInits || !ILE->getInit(Init)) {
 239     // FIXME: We probably don't need to handle references
 240     // specially here, since value-initialization of references is
 241     // handled in InitializationSequence.
 242     if (Field->getType()->isReferenceType()) {
 243       // C++ [dcl.init.aggr]p9:
 244       //   If an incomplete or empty initializer-list leaves a
 245       //   member of reference type uninitialized, the program is
 246       //   ill-formed.
 247       SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
 248         << Field->getType()
 249         << ILE->getSyntacticForm()->getSourceRange();
 250       SemaRef.Diag(Field->getLocation(),
 251                    diag::note_uninit_reference_member);
 252       hadError = true;
 253       return;
 254     }
 255
 256     InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
 257                                                               true);
 258     InitializationSequence InitSeq(SemaRef, MemberEntity, Kind, 0, 0);
 259     if (!InitSeq) {
 260       InitSeq.Diagnose(SemaRef, MemberEntity, Kind, 0, 0);
 261       hadError = true;
 262       return;
 263     }
 264
 265     Sema::OwningExprResult MemberInit
 266       = InitSeq.Perform(SemaRef, MemberEntity, Kind,
 267                         Sema::MultiExprArg(SemaRef, 0, 0));
 268     if (MemberInit.isInvalid()) {
 269       hadError = true;
 270       return;
 271     }
 272
 273     if (hadError) {
 274       // Do nothing
 275     } else if (Init < NumInits) {
 276       ILE->setInit(Init, MemberInit.takeAs<Expr>());
 277     } else if (InitSeq.getKind()
 278                  == InitializationSequence::ConstructorInitialization) {
 279       // Value-initialization requires a constructor call, so
 280       // extend the initializer list to include the constructor
 281       // call and make a note that we'll need to take another pass
 282       // through the initializer list.
 283       ILE->updateInit(Init, MemberInit.takeAs<Expr>());
 284       RequiresSecondPass = true;
 285     }
 286   } else if (InitListExpr *InnerILE
 287                = dyn_cast<InitListExpr>(ILE->getInit(Init)))
 288     FillInValueInitializations(MemberEntity, InnerILE,
 289                                RequiresSecondPass);
 290 }
 291
 292 /// Recursively replaces NULL values within the given initializer list
 293 /// with expressions that perform value-initialization of the
 294 /// appropriate type.
 295 void
 296 InitListChecker::FillInValueInitializations(const InitializedEntity &Entity,
 297                                             InitListExpr *ILE,
 298                                             bool &RequiresSecondPass) {
 299   assert((ILE->getType() != SemaRef.Context.VoidTy) &&
 300          "Should not have void type");
 301   SourceLocation Loc = ILE->getSourceRange().getBegin();
 302   if (ILE->getSyntacticForm())
 303     Loc = ILE->getSyntacticForm()->getSourceRange().getBegin();
 304
 305   if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
 306     if (RType->getDecl()->isUnion() &&
 307         ILE->getInitializedFieldInUnion())
 308       FillInValueInitForField(0, ILE->getInitializedFieldInUnion(),
 309                               Entity, ILE, RequiresSecondPass);
 310     else {
 311       unsigned Init = 0;
 312       for (RecordDecl::field_iterator
 313              Field = RType->getDecl()->field_begin(),
 314              FieldEnd = RType->getDecl()->field_end();
 315            Field != FieldEnd; ++Field) {
 316         if (Field->isUnnamedBitfield())
 317           continue;
 318
 319         if (hadError)
 320           return;
 321
 322         FillInValueInitForField(Init, *Field, Entity, ILE, RequiresSecondPass);
 323         if (hadError)
 324           return;
 325
 326         ++Init;
 327
 328         // Only look at the first initialization of a union.
 329         if (RType->getDecl()->isUnion())
 330           break;
 331       }
 332     }
 333
 334     return;
 335   }
 336
 337   QualType ElementType;
 338
 339   InitializedEntity ElementEntity = Entity;
 340   unsigned NumInits = ILE->getNumInits();
 341   unsigned NumElements = NumInits;
 342   if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
 343     ElementType = AType->getElementType();
 344     if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
 345       NumElements = CAType->getSize().getZExtValue();
 346     ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
 347                                                          0, Entity);
 348   } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
 349     ElementType = VType->getElementType();
 350     NumElements = VType->getNumElements();
 351     ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
 352                                                          0, Entity);
 353   } else
 354     ElementType = ILE->getType();
 355
 356
 357   for (unsigned Init = 0; Init != NumElements; ++Init) {
 358     if (hadError)
 359       return;
 360
 361     if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
 362         ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
 363       ElementEntity.setElementIndex(Init);
 364
 365     if (Init >= NumInits || !ILE->getInit(Init)) {
 366       InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
 367                                                                 true);
 368       InitializationSequence InitSeq(SemaRef, ElementEntity, Kind, 0, 0);
 369       if (!InitSeq) {
 370         InitSeq.Diagnose(SemaRef, ElementEntity, Kind, 0, 0);
 371         hadError = true;
 372         return;
 373       }
 374
 375       Sema::OwningExprResult ElementInit
 376         = InitSeq.Perform(SemaRef, ElementEntity, Kind,
 377                           Sema::MultiExprArg(SemaRef, 0, 0));
 378       if (ElementInit.isInvalid()) {
 379         hadError = true;
 380         return;
 381       }
 382
 383       if (hadError) {
 384         // Do nothing
 385       } else if (Init < NumInits) {
 386         ILE->setInit(Init, ElementInit.takeAs<Expr>());
 387       } else if (InitSeq.getKind()
 388                    == InitializationSequence::ConstructorInitialization) {
 389         // Value-initialization requires a constructor call, so
 390         // extend the initializer list to include the constructor
 391         // call and make a note that we'll need to take another pass
 392         // through the initializer list.
 393         ILE->updateInit(Init, ElementInit.takeAs<Expr>());
 394         RequiresSecondPass = true;
 395       }
 396     } else if (InitListExpr *InnerILE
 397                  = dyn_cast<InitListExpr>(ILE->getInit(Init)))
 398       FillInValueInitializations(ElementEntity, InnerILE, RequiresSecondPass);
 399   }
 400 }
 401
 402
 403 InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
 404                                  InitListExpr *IL, QualType &T)
 405   : SemaRef(S) {
 406   hadError = false;
 407
 408   unsigned newIndex = 0;
 409   unsigned newStructuredIndex = 0;
 410   FullyStructuredList
 411     = getStructuredSubobjectInit(IL, newIndex, T, 0, 0, IL->getSourceRange());
 412   CheckExplicitInitList(Entity, IL, T, newIndex,
 413                         FullyStructuredList, newStructuredIndex,
 414                         /*TopLevelObject=*/true);
 415
 416   if (!hadError) {
 417     bool RequiresSecondPass = false;
 418     FillInValueInitializations(Entity, FullyStructuredList, RequiresSecondPass);
 419     if (RequiresSecondPass && !hadError)
 420       FillInValueInitializations(Entity, FullyStructuredList,
 421                                  RequiresSecondPass);
 422   }
 423 }
 424
 425 int InitListChecker::numArrayElements(QualType DeclType) {
 426   // FIXME: use a proper constant
 427   int maxElements = 0x7FFFFFFF;
 428   if (const ConstantArrayType *CAT =
 429         SemaRef.Context.getAsConstantArrayType(DeclType)) {
 430     maxElements = static_cast<int>(CAT->getSize().getZExtValue());
 431   }
 432   return maxElements;
 433 }
 434
 435 int InitListChecker::numStructUnionElements(QualType DeclType) {
 436   RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
 437   int InitializableMembers = 0;
 438   for (RecordDecl::field_iterator
 439          Field = structDecl->field_begin(),
 440          FieldEnd = structDecl->field_end();
 441        Field != FieldEnd; ++Field) {
 442     if ((*Field)->getIdentifier() || !(*Field)->isBitField())
 443       ++InitializableMembers;
 444   }
 445   if (structDecl->isUnion())
 446     return std::min(InitializableMembers, 1);
 447   return InitializableMembers - structDecl->hasFlexibleArrayMember();
 448 }
 449
 450 void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
 451                                             InitListExpr *ParentIList,
 452                                             QualType T, unsigned &Index,
 453                                             InitListExpr *StructuredList,
 454                                             unsigned &StructuredIndex,
 455                                             bool TopLevelObject) {
 456   int maxElements = 0;
 457
 458   if (T->isArrayType())
 459     maxElements = numArrayElements(T);
 460   else if (T->isStructureType() || T->isUnionType())
 461     maxElements = numStructUnionElements(T);
 462   else if (T->isVectorType())
 463     maxElements = T->getAs<VectorType>()->getNumElements();
 464   else
 465     assert(0 && "CheckImplicitInitList(): Illegal type");
 466
 467   if (maxElements == 0) {
 468     SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
 469                   diag::err_implicit_empty_initializer);
 470     ++Index;
 471     hadError = true;
 472     return;
 473   }
 474
 475   // Build a structured initializer list corresponding to this subobject.
 476   InitListExpr *StructuredSubobjectInitList
 477     = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
 478                                  StructuredIndex,
 479           SourceRange(ParentIList->getInit(Index)->getSourceRange().getBegin(),
 480                       ParentIList->getSourceRange().getEnd()));
 481   unsigned StructuredSubobjectInitIndex = 0;
 482
 483   // Check the element types and build the structural subobject.
 484   unsigned StartIndex = Index;
 485   CheckListElementTypes(Entity, ParentIList, T,
 486                         /*SubobjectIsDesignatorContext=*/false, Index,
 487                         StructuredSubobjectInitList,
 488                         StructuredSubobjectInitIndex,
 489                         TopLevelObject);
 490   unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
 491   StructuredSubobjectInitList->setType(T);
 492
 493   // Update the structured sub-object initializer so that it's ending
 494   // range corresponds with the end of the last initializer it used.
 495   if (EndIndex < ParentIList->getNumInits()) {
 496     SourceLocation EndLoc
 497       = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
 498     StructuredSubobjectInitList->setRBraceLoc(EndLoc);
 499   }
 500 }
 501
 502 void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
 503                                             InitListExpr *IList, QualType &T,
 504                                             unsigned &Index,
 505                                             InitListExpr *StructuredList,
 506                                             unsigned &StructuredIndex,
 507                                             bool TopLevelObject) {
 508   assert(IList->isExplicit() && "Illegal Implicit InitListExpr");
 509   SyntacticToSemantic[IList] = StructuredList;
 510   StructuredList->setSyntacticForm(IList);
 511   CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
 512                         Index, StructuredList, StructuredIndex, TopLevelObject);
 513   IList->setType(T.getNonReferenceType());
 514   StructuredList->setType(T.getNonReferenceType());
 515   if (hadError)
 516     return;
 517
 518   if (Index < IList->getNumInits()) {
 519     // We have leftover initializers
 520     if (StructuredIndex == 1 &&
 521         IsStringInit(StructuredList->getInit(0), T, SemaRef.Context)) {
 522       unsigned DK = diag::warn_excess_initializers_in_char_array_initializer;
 523       if (SemaRef.getLangOptions().CPlusPlus) {
 524         DK = diag::err_excess_initializers_in_char_array_initializer;
 525         hadError = true;
 526       }
 527       // Special-case
 528       SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
 529         << IList->getInit(Index)->getSourceRange();
 530     } else if (!T->isIncompleteType()) {
 531       // Don't complain for incomplete types, since we'll get an error
 532       // elsewhere
 533       QualType CurrentObjectType = StructuredList->getType();
 534       int initKind =
 535         CurrentObjectType->isArrayType()? 0 :
 536         CurrentObjectType->isVectorType()? 1 :
 537         CurrentObjectType->isScalarType()? 2 :
 538         CurrentObjectType->isUnionType()? 3 :
 539         4;
 540
 541       unsigned DK = diag::warn_excess_initializers;
 542       if (SemaRef.getLangOptions().CPlusPlus) {
 543         DK = diag::err_excess_initializers;
 544         hadError = true;
 545       }
 546       if (SemaRef.getLangOptions().OpenCL && initKind == 1) {
 547         DK = diag::err_excess_initializers;
 548         hadError = true;
 549       }
 550
 551       SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
 552         << initKind << IList->getInit(Index)->getSourceRange();
 553     }
 554   }
 555
 556   if (T->isScalarType() && !TopLevelObject)
 557     SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init)
 558       << IList->getSourceRange()
 559       << CodeModificationHint::CreateRemoval(IList->getLocStart())
 560       << CodeModificationHint::CreateRemoval(IList->getLocEnd());
 561 }
 562
 563 void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
 564                                             InitListExpr *IList,
 565                                             QualType &DeclType,
 566                                             bool SubobjectIsDesignatorContext,
 567                                             unsigned &Index,
 568                                             InitListExpr *StructuredList,
 569                                             unsigned &StructuredIndex,
 570                                             bool TopLevelObject) {
 571   if (DeclType->isScalarType()) {
 572     CheckScalarType(Entity, IList, DeclType, Index,
 573                     StructuredList, StructuredIndex);
 574   } else if (DeclType->isVectorType()) {
 575     CheckVectorType(Entity, IList, DeclType, Index,
 576                     StructuredList, StructuredIndex);
 577   } else if (DeclType->isAggregateType()) {
 578     if (DeclType->isRecordType()) {
 579       RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
 580       CheckStructUnionTypes(Entity, IList, DeclType, RD->field_begin(),
 581                             SubobjectIsDesignatorContext, Index,
 582                             StructuredList, StructuredIndex,
 583                             TopLevelObject);
 584     } else if (DeclType->isArrayType()) {
 585       llvm::APSInt Zero(
 586                       SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
 587                       false);
 588       CheckArrayType(Entity, IList, DeclType, Zero,
 589                      SubobjectIsDesignatorContext, Index,
 590                      StructuredList, StructuredIndex);
 591     } else
 592       assert(0 && "Aggregate that isn't a structure or array?!");
 593   } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
 594     // This type is invalid, issue a diagnostic.
 595     ++Index;
 596     SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
 597       << DeclType;
 598     hadError = true;
 599   } else if (DeclType->isRecordType()) {
 600     // C++ [dcl.init]p14:
 601     //   [...] If the class is an aggregate (8.5.1), and the initializer
 602     //   is a brace-enclosed list, see 8.5.1.
 603     //
 604     // Note: 8.5.1 is handled below; here, we diagnose the case where
 605     // we have an initializer list and a destination type that is not
 606     // an aggregate.
 607     // FIXME: In C++0x, this is yet another form of initialization.
 608     SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
 609       << DeclType << IList->getSourceRange();
 610     hadError = true;
 611   } else if (DeclType->isReferenceType()) {
 612     CheckReferenceType(Entity, IList, DeclType, Index,
 613                        StructuredList, StructuredIndex);
 614   } else {
 615     // In C, all types are either scalars or aggregates, but
 616     // additional handling is needed here for C++ (and possibly others?).
 617     assert(0 && "Unsupported initializer type");
 618   }
 619 }
 620
 621 void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
 622                                           InitListExpr *IList,
 623                                           QualType ElemType,
 624                                           unsigned &Index,
 625                                           InitListExpr *StructuredList,
 626                                           unsigned &StructuredIndex) {
 627   Expr *expr = IList->getInit(Index);
 628   if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
 629     unsigned newIndex = 0;
 630     unsigned newStructuredIndex = 0;
 631     InitListExpr *newStructuredList
 632       = getStructuredSubobjectInit(IList, Index, ElemType,
 633                                    StructuredList, StructuredIndex,
 634                                    SubInitList->getSourceRange());
 635     CheckExplicitInitList(Entity, SubInitList, ElemType, newIndex,
 636                           newStructuredList, newStructuredIndex);
 637     ++StructuredIndex;
 638     ++Index;
 639   } else if (Expr *Str = IsStringInit(expr, ElemType, SemaRef.Context)) {
 640     CheckStringInit(Str, ElemType, SemaRef);
 641     UpdateStructuredListElement(StructuredList, StructuredIndex, Str);
 642     ++Index;
 643   } else if (ElemType->isScalarType()) {
 644     CheckScalarType(Entity, IList, ElemType, Index,
 645                     StructuredList, StructuredIndex);
 646   } else if (ElemType->isReferenceType()) {
 647     CheckReferenceType(Entity, IList, ElemType, Index,
 648                        StructuredList, StructuredIndex);
 649   } else {
 650     if (SemaRef.getLangOptions().CPlusPlus) {
 651       // C++ [dcl.init.aggr]p12:
 652       //   All implicit type conversions (clause 4) are considered when
 653       //   initializing the aggregate member with an ini- tializer from
 654       //   an initializer-list. If the initializer can initialize a
 655       //   member, the member is initialized. [...]
 656
 657       // FIXME: Better EqualLoc?
 658       InitializationKind Kind =
 659         InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
 660       InitializationSequence Seq(SemaRef, Entity, Kind, &expr, 1);
 661
 662       if (Seq) {
 663         Sema::OwningExprResult Result =
 664           Seq.Perform(SemaRef, Entity, Kind,
 665                       Sema::MultiExprArg(SemaRef, (void **)&expr, 1));
 666         if (Result.isInvalid())
 667           hadError = true;
 668
 669         UpdateStructuredListElement(StructuredList, StructuredIndex,
 670                                     Result.takeAs<Expr>());
 671         ++Index;
 672         return;
 673       }
 674
 675       // Fall through for subaggregate initialization
 676     } else {
 677       // C99 6.7.8p13:
 678       //
 679       //   The initializer for a structure or union object that has
 680       //   automatic storage duration shall be either an initializer
 681       //   list as described below, or a single expression that has
 682       //   compatible structure or union type. In the latter case, the
 683       //   initial value of the object, including unnamed members, is
 684       //   that of the expression.
 685       if ((ElemType->isRecordType() || ElemType->isVectorType()) &&
 686           SemaRef.Context.hasSameUnqualifiedType(expr->getType(), ElemType)) {
 687         UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
 688         ++Index;
 689         return;
 690       }
 691
 692       // Fall through for subaggregate initialization
 693     }
 694
 695     // C++ [dcl.init.aggr]p12:
 696     //
 697     //   [...] Otherwise, if the member is itself a non-empty
 698     //   subaggregate, brace elision is assumed and the initializer is
 699     //   considered for the initialization of the first member of
 700     //   the subaggregate.
 701     if (ElemType->isAggregateType() || ElemType->isVectorType()) {
 702       CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
 703                             StructuredIndex);
 704       ++StructuredIndex;
 705     } else {
 706       // We cannot initialize this element, so let
 707       // PerformCopyInitialization produce the appropriate diagnostic.
 708       SemaRef.PerformCopyInitialization(Entity, SourceLocation(),
 709                                         SemaRef.Owned(expr));
 710       IList->setInit(Index, 0);
 711       hadError = true;
 712       ++Index;
 713       ++StructuredIndex;
 714     }
 715   }
 716 }
 717
 718 void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
 719                                       InitListExpr *IList, QualType DeclType,
 720                                       unsigned &Index,
 721                                       InitListExpr *StructuredList,
 722                                       unsigned &StructuredIndex) {
 723   if (Index < IList->getNumInits()) {
 724     Expr *expr = IList->getInit(Index);
 725     if (isa<InitListExpr>(expr)) {
 726       SemaRef.Diag(IList->getLocStart(),
 727                     diag::err_many_braces_around_scalar_init)
 728         << IList->getSourceRange();
 729       hadError = true;
 730       ++Index;
 731       ++StructuredIndex;
 732       return;
 733     } else if (isa<DesignatedInitExpr>(expr)) {
 734       SemaRef.Diag(expr->getSourceRange().getBegin(),
 735                     diag::err_designator_for_scalar_init)
 736         << DeclType << expr->getSourceRange();
 737       hadError = true;
 738       ++Index;
 739       ++StructuredIndex;
 740       return;
 741     }
 742
 743     Sema::OwningExprResult Result =
 744       SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
 745                                         SemaRef.Owned(expr));
 746
 747     Expr *ResultExpr = 0;
 748
 749     if (Result.isInvalid())
 750       hadError = true; // types weren't compatible.
 751     else {
 752       ResultExpr = Result.takeAs<Expr>();
 753
 754       if (ResultExpr != expr) {
 755         // The type was promoted, update initializer list.
 756         IList->setInit(Index, ResultExpr);
 757       }
 758     }
 759     if (hadError)
 760       ++StructuredIndex;
 761     else
 762       UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
 763     ++Index;
 764   } else {
 765     SemaRef.Diag(IList->getLocStart(), diag::err_empty_scalar_initializer)
 766       << IList->getSourceRange();
 767     hadError = true;
 768     ++Index;
 769     ++StructuredIndex;
 770     return;
 771   }
 772 }
 773
 774 void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
 775                                          InitListExpr *IList, QualType DeclType,
 776                                          unsigned &Index,
 777                                          InitListExpr *StructuredList,
 778                                          unsigned &StructuredIndex) {
 779   if (Index < IList->getNumInits()) {
 780     Expr *expr = IList->getInit(Index);
 781     if (isa<InitListExpr>(expr)) {
 782       SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
 783         << DeclType << IList->getSourceRange();
 784       hadError = true;
 785       ++Index;
 786       ++StructuredIndex;
 787       return;
 788     }
 789
 790     Sema::OwningExprResult Result =
 791       SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
 792                                         SemaRef.Owned(expr));
 793
 794     if (Result.isInvalid())
 795       hadError = true;
 796
 797     expr = Result.takeAs<Expr>();
 798     IList->setInit(Index, expr);
 799
 800     if (hadError)
 801       ++StructuredIndex;
 802     else
 803       UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
 804     ++Index;
 805   } else {
 806     // FIXME: It would be wonderful if we could point at the actual member. In
 807     // general, it would be useful to pass location information down the stack,
 808     // so that we know the location (or decl) of the "current object" being
 809     // initialized.
 810     SemaRef.Diag(IList->getLocStart(),
 811                   diag::err_init_reference_member_uninitialized)
 812       << DeclType
 813       << IList->getSourceRange();
 814     hadError = true;
 815     ++Index;
 816     ++StructuredIndex;
 817     return;
 818   }
 819 }
 820
 821 void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
 822                                       InitListExpr *IList, QualType DeclType,
 823                                       unsigned &Index,
 824                                       InitListExpr *StructuredList,
 825                                       unsigned &StructuredIndex) {
 826   if (Index < IList->getNumInits()) {
 827     const VectorType *VT = DeclType->getAs<VectorType>();
 828     unsigned maxElements = VT->getNumElements();
 829     unsigned numEltsInit = 0;
 830     QualType elementType = VT->getElementType();
 831
 832     if (!SemaRef.getLangOptions().OpenCL) {
 833       InitializedEntity ElementEntity =
 834         InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
 835
 836       for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
 837         // Don't attempt to go past the end of the init list
 838         if (Index >= IList->getNumInits())
 839           break;
 840
 841         ElementEntity.setElementIndex(Index);
 842         CheckSubElementType(ElementEntity, IList, elementType, Index,
 843                             StructuredList, StructuredIndex);
 844       }
 845     } else {
 846       InitializedEntity ElementEntity =
 847         InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
 848
 849       // OpenCL initializers allows vectors to be constructed from vectors.
 850       for (unsigned i = 0; i < maxElements; ++i) {
 851         // Don't attempt to go past the end of the init list
 852         if (Index >= IList->getNumInits())
 853           break;
 854
 855         ElementEntity.setElementIndex(Index);
 856
 857         QualType IType = IList->getInit(Index)->getType();
 858         if (!IType->isVectorType()) {
 859           CheckSubElementType(ElementEntity, IList, elementType, Index,
 860                               StructuredList, StructuredIndex);
 861           ++numEltsInit;
 862         } else {
 863           const VectorType *IVT = IType->getAs<VectorType>();
 864           unsigned numIElts = IVT->getNumElements();
 865           QualType VecType = SemaRef.Context.getExtVectorType(elementType,
 866                                                               numIElts);
 867           CheckSubElementType(ElementEntity, IList, VecType, Index,
 868                               StructuredList, StructuredIndex);
 869           numEltsInit += numIElts;
 870         }
 871       }
 872     }
 873
 874     // OpenCL & AltiVec require all elements to be initialized.
 875     if (numEltsInit != maxElements)
 876       if (SemaRef.getLangOptions().OpenCL || SemaRef.getLangOptions().AltiVec)
 877         SemaRef.Diag(IList->getSourceRange().getBegin(),
 878                      diag::err_vector_incorrect_num_initializers)
 879           << (numEltsInit < maxElements) << maxElements << numEltsInit;
 880   }
 881 }
 882
 883 void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
 884                                      InitListExpr *IList, QualType &DeclType,
 885                                      llvm::APSInt elementIndex,
 886                                      bool SubobjectIsDesignatorContext,
 887                                      unsigned &Index,
 888                                      InitListExpr *StructuredList,
 889                                      unsigned &StructuredIndex) {
 890   // Check for the special-case of initializing an array with a string.
 891   if (Index < IList->getNumInits()) {
 892     if (Expr *Str = IsStringInit(IList->getInit(Index), DeclType,
 893                                  SemaRef.Context)) {
 894       CheckStringInit(Str, DeclType, SemaRef);
 895       // We place the string literal directly into the resulting
 896       // initializer list. This is the only place where the structure
 897       // of the structured initializer list doesn't match exactly,
 898       // because doing so would involve allocating one character
 899       // constant for each string.
 900       UpdateStructuredListElement(StructuredList, StructuredIndex, Str);
 901       StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
 902       ++Index;
 903       return;
 904     }
 905   }
 906   if (const VariableArrayType *VAT =
 907         SemaRef.Context.getAsVariableArrayType(DeclType)) {
 908     // Check for VLAs; in standard C it would be possible to check this
 909     // earlier, but I don't know where clang accepts VLAs (gcc accepts
 910     // them in all sorts of strange places).
 911     SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
 912                   diag::err_variable_object_no_init)
 913       << VAT->getSizeExpr()->getSourceRange();
 914     hadError = true;
 915     ++Index;
 916     ++StructuredIndex;
 917     return;
 918   }
 919
 920   // We might know the maximum number of elements in advance.
 921   llvm::APSInt maxElements(elementIndex.getBitWidth(),
 922                            elementIndex.isUnsigned());
 923   bool maxElementsKnown = false;
 924   if (const ConstantArrayType *CAT =
 925         SemaRef.Context.getAsConstantArrayType(DeclType)) {
 926     maxElements = CAT->getSize();
 927     elementIndex.extOrTrunc(maxElements.getBitWidth());
 928     elementIndex.setIsUnsigned(maxElements.isUnsigned());
 929     maxElementsKnown = true;
 930   }
 931
 932   QualType elementType = SemaRef.Context.getAsArrayType(DeclType)
 933                              ->getElementType();
 934   while (Index < IList->getNumInits()) {
 935     Expr *Init = IList->getInit(Index);
 936     if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
 937       // If we're not the subobject that matches up with the '{' for
 938       // the designator, we shouldn't be handling the
 939       // designator. Return immediately.
 940       if (!SubobjectIsDesignatorContext)
 941         return;
 942
 943       // Handle this designated initializer. elementIndex will be
 944       // updated to be the next array element we'll initialize.
 945       if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
 946                                      DeclType, 0, &elementIndex, Index,
 947                                      StructuredList, StructuredIndex, true,
 948                                      false)) {
 949         hadError = true;
 950         continue;
 951       }
 952
 953       if (elementIndex.getBitWidth() > maxElements.getBitWidth())
 954         maxElements.extend(elementIndex.getBitWidth());
 955       else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
 956         elementIndex.extend(maxElements.getBitWidth());
 957       elementIndex.setIsUnsigned(maxElements.isUnsigned());
 958
 959       // If the array is of incomplete type, keep track of the number of
 960       // elements in the initializer.
 961       if (!maxElementsKnown && elementIndex > maxElements)
 962         maxElements = elementIndex;
 963
 964       continue;
 965     }
 966
 967     // If we know the maximum number of elements, and we've already
 968     // hit it, stop consuming elements in the initializer list.
 969     if (maxElementsKnown && elementIndex == maxElements)
 970       break;
 971
 972     InitializedEntity ElementEntity =
 973       InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
 974                                            Entity);
 975     // Check this element.
 976     CheckSubElementType(ElementEntity, IList, elementType, Index,
 977                         StructuredList, StructuredIndex);
 978     ++elementIndex;
 979
 980     // If the array is of incomplete type, keep track of the number of
 981     // elements in the initializer.
 982     if (!maxElementsKnown && elementIndex > maxElements)
 983       maxElements = elementIndex;
 984   }
 985   if (!hadError && DeclType->isIncompleteArrayType()) {
 986     // If this is an incomplete array type, the actual type needs to
 987     // be calculated here.
 988     llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
 989     if (maxElements == Zero) {
 990       // Sizing an array implicitly to zero is not allowed by ISO C,
 991       // but is supported by GNU.
 992       SemaRef.Diag(IList->getLocStart(),
 993                     diag::ext_typecheck_zero_array_size);
 994     }
 995
 996     DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
 997                                                      ArrayType::Normal, 0);
 998   }
 999 }
1000
1001 void InitListChecker::CheckStructUnionTypes(const InitializedEntity &Entity,
1002                                             InitListExpr *IList,
1003                                             QualType DeclType,
1004                                             RecordDecl::field_iterator Field,
1005                                             bool SubobjectIsDesignatorContext,
1006                                             unsigned &Index,
1007                                             InitListExpr *StructuredList,
1008                                             unsigned &StructuredIndex,
1009                                             bool TopLevelObject) {
1010   RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl();
1011
1012   // If the record is invalid, some of it's members are invalid. To avoid
1013   // confusion, we forgo checking the intializer for the entire record.
1014   if (structDecl->isInvalidDecl()) {
1015     hadError = true;
1016     return;
1017   }
1018
1019   if (DeclType->isUnionType() && IList->getNumInits() == 0) {
1020     // Value-initialize the first named member of the union.
1021     RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1022     for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1023          Field != FieldEnd; ++Field) {
1024       if (Field->getDeclName()) {
1025         StructuredList->setInitializedFieldInUnion(*Field);
1026         break;
1027       }
1028     }
1029     return;
1030   }
1031
1032   // If structDecl is a forward declaration, this loop won't do
1033   // anything except look at designated initializers; That's okay,
1034   // because an error should get printed out elsewhere. It might be
1035   // worthwhile to skip over the rest of the initializer, though.
1036   RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1037   RecordDecl::field_iterator FieldEnd = RD->field_end();
1038   bool InitializedSomething = false;
1039   while (Index < IList->getNumInits()) {
1040     Expr *Init = IList->getInit(Index);
1041
1042     if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1043       // If we're not the subobject that matches up with the '{' for
1044       // the designator, we shouldn't be handling the
1045       // designator. Return immediately.
1046       if (!SubobjectIsDesignatorContext)
1047         return;
1048
1049       // Handle this designated initializer. Field will be updated to
1050       // the next field that we'll be initializing.
1051       if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1052                                      DeclType, &Field, 0, Index,
1053                                      StructuredList, StructuredIndex,
1054                                      true, TopLevelObject))
1055         hadError = true;
1056
1057       InitializedSomething = true;
1058       continue;
1059     }
1060
1061     if (Field == FieldEnd) {
1062       // We've run out of fields. We're done.
1063       break;
1064     }
1065
1066     // We've already initialized a member of a union. We're done.
1067     if (InitializedSomething && DeclType->isUnionType())
1068       break;
1069
1070     // If we've hit the flexible array member at the end, we're done.
1071     if (Field->getType()->isIncompleteArrayType())
1072       break;
1073
1074     if (Field->isUnnamedBitfield()) {
1075       // Don't initialize unnamed bitfields, e.g. "int : 20;"
1076       ++Field;
1077       continue;
1078     }
1079
1080     InitializedEntity MemberEntity =
1081       InitializedEntity::InitializeMember(*Field, &Entity);
1082     CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1083                         StructuredList, StructuredIndex);
1084     InitializedSomething = true;
1085
1086     if (DeclType->isUnionType()) {
1087       // Initialize the first field within the union.
1088       StructuredList->setInitializedFieldInUnion(*Field);
1089     }
1090
1091     ++Field;
1092   }
1093
1094   if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
1095       Index >= IList->getNumInits())
1096     return;
1097
1098   // Handle GNU flexible array initializers.
1099   if (!TopLevelObject &&
1100       (!isa<InitListExpr>(IList->getInit(Index)) ||
1101        cast<InitListExpr>(IList->getInit(Index))->getNumInits() > 0)) {
1102     SemaRef.Diag(IList->getInit(Index)->getSourceRange().getBegin(),
1103                   diag::err_flexible_array_init_nonempty)
1104       << IList->getInit(Index)->getSourceRange().getBegin();
1105     SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1106       << *Field;
1107     hadError = true;
1108     ++Index;
1109     return;
1110   } else {
1111     SemaRef.Diag(IList->getInit(Index)->getSourceRange().getBegin(),
1112                  diag::ext_flexible_array_init)
1113       << IList->getInit(Index)->getSourceRange().getBegin();
1114     SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1115       << *Field;
1116   }
1117
1118   InitializedEntity MemberEntity =
1119     InitializedEntity::InitializeMember(*Field, &Entity);
1120
1121   if (isa<InitListExpr>(IList->getInit(Index)))
1122     CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1123                         StructuredList, StructuredIndex);
1124   else
1125     CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
1126                           StructuredList, StructuredIndex);
1127 }
1128
1129 /// \brief Expand a field designator that refers to a member of an
1130 /// anonymous struct or union into a series of field designators that
1131 /// refers to the field within the appropriate subobject.
1132 ///
1133 /// Field/FieldIndex will be updated to point to the (new)
1134 /// currently-designated field.
1135 static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
1136                                            DesignatedInitExpr *DIE,
1137                                            unsigned DesigIdx,
1138                                            FieldDecl *Field,
1139                                         RecordDecl::field_iterator &FieldIter,
1140                                            unsigned &FieldIndex) {
1141   typedef DesignatedInitExpr::Designator Designator;
1142
1143   // Build the path from the current object to the member of the
1144   // anonymous struct/union (backwards).
1145   llvm::SmallVector<FieldDecl *, 4> Path;
1146   SemaRef.BuildAnonymousStructUnionMemberPath(Field, Path);
1147
1148   // Build the replacement designators.
1149   llvm::SmallVector<Designator, 4> Replacements;
1150   for (llvm::SmallVector<FieldDecl *, 4>::reverse_iterator
1151          FI = Path.rbegin(), FIEnd = Path.rend();
1152        FI != FIEnd; ++FI) {
1153     if (FI + 1 == FIEnd)
1154       Replacements.push_back(Designator((IdentifierInfo *)0,
1155                                     DIE->getDesignator(DesigIdx)->getDotLoc(),
1156                                 DIE->getDesignator(DesigIdx)->getFieldLoc()));
1157     else
1158       Replacements.push_back(Designator((IdentifierInfo *)0, SourceLocation(),
1159                                         SourceLocation()));
1160     Replacements.back().setField(*FI);
1161   }
1162
1163   // Expand the current designator into the set of replacement
1164   // designators, so we have a full subobject path down to where the
1165   // member of the anonymous struct/union is actually stored.
1166   DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
1167                         &Replacements[0] + Replacements.size());
1168
1169   // Update FieldIter/FieldIndex;
1170   RecordDecl *Record = cast<RecordDecl>(Path.back()->getDeclContext());
1171   FieldIter = Record->field_begin();
1172   FieldIndex = 0;
1173   for (RecordDecl::field_iterator FEnd = Record->field_end();
1174        FieldIter != FEnd; ++FieldIter) {
1175     if (FieldIter->isUnnamedBitfield())
1176         continue;
1177
1178     if (*FieldIter == Path.back())
1179       return;
1180
1181     ++FieldIndex;
1182   }
1183
1184   assert(false && "Unable to find anonymous struct/union field");
1185 }
1186
1187 /// @brief Check the well-formedness of a C99 designated initializer.
1188 ///
1189 /// Determines whether the designated initializer @p DIE, which
1190 /// resides at the given @p Index within the initializer list @p
1191 /// IList, is well-formed for a current object of type @p DeclType
1192 /// (C99 6.7.8). The actual subobject that this designator refers to
1193 /// within the current subobject is returned in either
1194 /// @p NextField or @p NextElementIndex (whichever is appropriate).
1195 ///
1196 /// @param IList  The initializer list in which this designated
1197 /// initializer occurs.
1198 ///
1199 /// @param DIE The designated initializer expression.
1200 ///
1201 /// @param DesigIdx  The index of the current designator.
1202 ///
1203 /// @param DeclType  The type of the "current object" (C99 6.7.8p17),
1204 /// into which the designation in @p DIE should refer.
1205 ///
1206 /// @param NextField  If non-NULL and the first designator in @p DIE is
1207 /// a field, this will be set to the field declaration corresponding
1208 /// to the field named by the designator.
1209 ///
1210 /// @param NextElementIndex  If non-NULL and the first designator in @p
1211 /// DIE is an array designator or GNU array-range designator, this
1212 /// will be set to the last index initialized by this designator.
1213 ///
1214 /// @param Index  Index into @p IList where the designated initializer
1215 /// @p DIE occurs.
1216 ///
1217 /// @param StructuredList  The initializer list expression that
1218 /// describes all of the subobject initializers in the order they'll
1219 /// actually be initialized.
1220 ///
1221 /// @returns true if there was an error, false otherwise.
1222 bool
1223 InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
1224                                             InitListExpr *IList,
1225                                       DesignatedInitExpr *DIE,
1226                                       unsigned DesigIdx,
1227                                       QualType &CurrentObjectType,
1228                                       RecordDecl::field_iterator *NextField,
1229                                       llvm::APSInt *NextElementIndex,
1230                                       unsigned &Index,
1231                                       InitListExpr *StructuredList,
1232                                       unsigned &StructuredIndex,
1233                                             bool FinishSubobjectInit,
1234                                             bool TopLevelObject) {
1235   if (DesigIdx == DIE->size()) {
1236     // Check the actual initialization for the designated object type.
1237     bool prevHadError = hadError;
1238
1239     // Temporarily remove the designator expression from the
1240     // initializer list that the child calls see, so that we don't try
1241     // to re-process the designator.
1242     unsigned OldIndex = Index;
1243     IList->setInit(OldIndex, DIE->getInit());
1244
1245     CheckSubElementType(Entity, IList, CurrentObjectType, Index,
1246                         StructuredList, StructuredIndex);
1247
1248     // Restore the designated initializer expression in the syntactic
1249     // form of the initializer list.
1250     if (IList->getInit(OldIndex) != DIE->getInit())
1251       DIE->setInit(IList->getInit(OldIndex));
1252     IList->setInit(OldIndex, DIE);
1253
1254     return hadError && !prevHadError;
1255   }
1256
1257   bool IsFirstDesignator = (DesigIdx == 0);
1258   assert((IsFirstDesignator || StructuredList) &&
1259          "Need a non-designated initializer list to start from");
1260
1261   DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
1262   // Determine the structural initializer list that corresponds to the
1263   // current subobject.
1264   StructuredList = IsFirstDesignator? SyntacticToSemantic[IList]
1265     : getStructuredSubobjectInit(IList, Index, CurrentObjectType,
1266                                  StructuredList, StructuredIndex,
1267                                  SourceRange(D->getStartLocation(),
1268                                              DIE->getSourceRange().getEnd()));
1269   assert(StructuredList && "Expected a structured initializer list");
1270
1271   if (D->isFieldDesignator()) {
1272     // C99 6.7.8p7:
1273     //
1274     //   If a designator has the form
1275     //
1276     //      . identifier
1277     //
1278     //   then the current object (defined below) shall have
1279     //   structure or union type and the identifier shall be the
1280     //   name of a member of that type.
1281     const RecordType *RT = CurrentObjectType->getAs<RecordType>();
1282     if (!RT) {
1283       SourceLocation Loc = D->getDotLoc();
1284       if (Loc.isInvalid())
1285         Loc = D->getFieldLoc();
1286       SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
1287         << SemaRef.getLangOptions().CPlusPlus << CurrentObjectType;
1288       ++Index;
1289       return true;
1290     }
1291
1292     // Note: we perform a linear search of the fields here, despite
1293     // the fact that we have a faster lookup method, because we always
1294     // need to compute the field's index.
1295     FieldDecl *KnownField = D->getField();
1296     IdentifierInfo *FieldName = D->getFieldName();
1297     unsigned FieldIndex = 0;
1298     RecordDecl::field_iterator
1299       Field = RT->getDecl()->field_begin(),
1300       FieldEnd = RT->getDecl()->field_end();
1301     for (; Field != FieldEnd; ++Field) {
1302       if (Field->isUnnamedBitfield())
1303         continue;
1304
1305       if (KnownField == *Field || Field->getIdentifier() == FieldName)
1306         break;
1307
1308       ++FieldIndex;
1309     }
1310
1311     if (Field == FieldEnd) {
1312       // There was no normal field in the struct with the designated
1313       // name. Perform another lookup for this name, which may find
1314       // something that we can't designate (e.g., a member function),
1315       // may find nothing, or may find a member of an anonymous
1316       // struct/union.
1317       DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
1318       FieldDecl *ReplacementField = 0;
1319       if (Lookup.first == Lookup.second) {
1320         // Name lookup didn't find anything. Determine whether this
1321         // was a typo for another field name.
1322         LookupResult R(SemaRef, FieldName, D->getFieldLoc(),
1323                        Sema::LookupMemberName);
1324         if (SemaRef.CorrectTypo(R, /*Scope=*/0, /*SS=*/0, RT->getDecl()) &&
1325             (ReplacementField = R.getAsSingle<FieldDecl>()) &&
1326             ReplacementField->getDeclContext()->getLookupContext()
1327                                                       ->Equals(RT->getDecl())) {
1328           SemaRef.Diag(D->getFieldLoc(),
1329                        diag::err_field_designator_unknown_suggest)
1330             << FieldName << CurrentObjectType << R.getLookupName()
1331             << CodeModificationHint::CreateReplacement(D->getFieldLoc(),
1332                                                R.getLookupName().getAsString());
1333           SemaRef.Diag(ReplacementField->getLocation(),
1334                        diag::note_previous_decl)
1335             << ReplacementField->getDeclName();
1336         } else {
1337           SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
1338             << FieldName << CurrentObjectType;
1339           ++Index;
1340           return true;
1341         }
1342       } else if (!KnownField) {
1343         // Determine whether we found a field at all.
1344         ReplacementField = dyn_cast<FieldDecl>(*Lookup.first);
1345       }
1346
1347       if (!ReplacementField) {
1348         // Name lookup found something, but it wasn't a field.
1349         SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
1350           << FieldName;
1351         SemaRef.Diag((*Lookup.first)->getLocation(),
1352                       diag::note_field_designator_found);
1353         ++Index;
1354         return true;
1355       }
1356
1357       if (!KnownField &&
1358           cast<RecordDecl>((ReplacementField)->getDeclContext())
1359                                                  ->isAnonymousStructOrUnion()) {
1360         // Handle an field designator that refers to a member of an
1361         // anonymous struct or union.
1362         ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx,
1363                                        ReplacementField,
1364                                        Field, FieldIndex);
1365         D = DIE->getDesignator(DesigIdx);
1366       } else if (!KnownField) {
1367         // The replacement field comes from typo correction; find it
1368         // in the list of fields.
1369         FieldIndex = 0;
1370         Field = RT->getDecl()->field_begin();
1371         for (; Field != FieldEnd; ++Field) {
1372           if (Field->isUnnamedBitfield())
1373             continue;
1374
1375           if (ReplacementField == *Field ||
1376               Field->getIdentifier() == ReplacementField->getIdentifier())
1377             break;
1378
1379           ++FieldIndex;
1380         }
1381       }
1382     } else if (!KnownField &&
1383                cast<RecordDecl>((*Field)->getDeclContext())
1384                  ->isAnonymousStructOrUnion()) {
1385       ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, *Field,
1386                                      Field, FieldIndex);
1387       D = DIE->getDesignator(DesigIdx);
1388     }
1389
1390     // All of the fields of a union are located at the same place in
1391     // the initializer list.
1392     if (RT->getDecl()->isUnion()) {
1393       FieldIndex = 0;
1394       StructuredList->setInitializedFieldInUnion(*Field);
1395     }
1396
1397     // Update the designator with the field declaration.
1398     D->setField(*Field);
1399
1400     // Make sure that our non-designated initializer list has space
1401     // for a subobject corresponding to this field.
1402     if (FieldIndex >= StructuredList->getNumInits())
1403       StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
1404
1405     // This designator names a flexible array member.
1406     if (Field->getType()->isIncompleteArrayType()) {
1407       bool Invalid = false;
1408       if ((DesigIdx + 1) != DIE->size()) {
1409         // We can't designate an object within the flexible array
1410         // member (because GCC doesn't allow it).
1411         DesignatedInitExpr::Designator *NextD
1412           = DIE->getDesignator(DesigIdx + 1);
1413         SemaRef.Diag(NextD->getStartLocation(),
1414                       diag::err_designator_into_flexible_array_member)
1415           << SourceRange(NextD->getStartLocation(),
1416                          DIE->getSourceRange().getEnd());
1417         SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1418           << *Field;
1419         Invalid = true;
1420       }
1421
1422       if (!hadError && !isa<InitListExpr>(DIE->getInit())) {
1423         // The initializer is not an initializer list.
1424         SemaRef.Diag(DIE->getInit()->getSourceRange().getBegin(),
1425                       diag::err_flexible_array_init_needs_braces)
1426           << DIE->getInit()->getSourceRange();
1427         SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1428           << *Field;
1429         Invalid = true;
1430       }
1431
1432       // Handle GNU flexible array initializers.
1433       if (!Invalid && !TopLevelObject &&
1434           cast<InitListExpr>(DIE->getInit())->getNumInits() > 0) {
1435         SemaRef.Diag(DIE->getSourceRange().getBegin(),
1436                       diag::err_flexible_array_init_nonempty)
1437           << DIE->getSourceRange().getBegin();
1438         SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1439           << *Field;
1440         Invalid = true;
1441       }
1442
1443       if (Invalid) {
1444         ++Index;
1445         return true;
1446       }
1447
1448       // Initialize the array.
1449       bool prevHadError = hadError;
1450       unsigned newStructuredIndex = FieldIndex;
1451       unsigned OldIndex = Index;
1452       IList->setInit(Index, DIE->getInit());
1453
1454       InitializedEntity MemberEntity =
1455         InitializedEntity::InitializeMember(*Field, &Entity);
1456       CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1457                           StructuredList, newStructuredIndex);
1458
1459       IList->setInit(OldIndex, DIE);
1460       if (hadError && !prevHadError) {
1461         ++Field;
1462         ++FieldIndex;
1463         if (NextField)
1464           *NextField = Field;
1465         StructuredIndex = FieldIndex;
1466         return true;
1467       }
1468     } else {
1469       // Recurse to check later designated subobjects.
1470       QualType FieldType = (*Field)->getType();
1471       unsigned newStructuredIndex = FieldIndex;
1472
1473       InitializedEntity MemberEntity =
1474         InitializedEntity::InitializeMember(*Field, &Entity);
1475       if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
1476                                      FieldType, 0, 0, Index,
1477                                      StructuredList, newStructuredIndex,
1478                                      true, false))
1479         return true;
1480     }
1481
1482     // Find the position of the next field to be initialized in this
1483     // subobject.
1484     ++Field;
1485     ++FieldIndex;
1486
1487     // If this the first designator, our caller will continue checking
1488     // the rest of this struct/class/union subobject.
1489     if (IsFirstDesignator) {
1490       if (NextField)
1491         *NextField = Field;
1492       StructuredIndex = FieldIndex;
1493       return false;
1494     }
1495
1496     if (!FinishSubobjectInit)
1497       return false;
1498
1499     // We've already initialized something in the union; we're done.
1500     if (RT->getDecl()->isUnion())
1501       return hadError;
1502
1503     // Check the remaining fields within this class/struct/union subobject.
1504     bool prevHadError = hadError;
1505
1506     CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index,
1507                           StructuredList, FieldIndex);
1508     return hadError && !prevHadError;
1509   }
1510
1511   // C99 6.7.8p6:
1512   //
1513   //   If a designator has the form
1514   //
1515   //      [ constant-expression ]
1516   //
1517   //   then the current object (defined below) shall have array
1518   //   type and the expression shall be an integer constant
1519   //   expression. If the array is of unknown size, any
1520   //   nonnegative value is valid.
1521   //
1522   // Additionally, cope with the GNU extension that permits
1523   // designators of the form
1524   //
1525   //      [ constant-expression ... constant-expression ]
1526   const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
1527   if (!AT) {
1528     SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
1529       << CurrentObjectType;
1530     ++Index;
1531     return true;
1532   }
1533
1534   Expr *IndexExpr = 0;
1535   llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
1536   if (D->isArrayDesignator()) {
1537     IndexExpr = DIE->getArrayIndex(*D);
1538     DesignatedStartIndex = IndexExpr->EvaluateAsInt(SemaRef.Context);
1539     DesignatedEndIndex = DesignatedStartIndex;
1540   } else {
1541     assert(D->isArrayRangeDesignator() && "Need array-range designator");
1542
1543
1544     DesignatedStartIndex =
1545       DIE->getArrayRangeStart(*D)->EvaluateAsInt(SemaRef.Context);
1546     DesignatedEndIndex =
1547       DIE->getArrayRangeEnd(*D)->EvaluateAsInt(SemaRef.Context);
1548     IndexExpr = DIE->getArrayRangeEnd(*D);
1549
1550     if (DesignatedStartIndex.getZExtValue() !=DesignatedEndIndex.getZExtValue())
1551       FullyStructuredList->sawArrayRangeDesignator();
1552   }
1553
1554   if (isa<ConstantArrayType>(AT)) {
1555     llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
1556     DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
1557     DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
1558     DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
1559     DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
1560     if (DesignatedEndIndex >= MaxElements) {
1561       SemaRef.Diag(IndexExpr->getSourceRange().getBegin(),
1562                     diag::err_array_designator_too_large)
1563         << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
1564         << IndexExpr->getSourceRange();
1565       ++Index;
1566       return true;
1567     }
1568   } else {
1569     // Make sure the bit-widths and signedness match.
1570     if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth())
1571       DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth());
1572     else if (DesignatedStartIndex.getBitWidth() <
1573              DesignatedEndIndex.getBitWidth())
1574       DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth());
1575     DesignatedStartIndex.setIsUnsigned(true);
1576     DesignatedEndIndex.setIsUnsigned(true);
1577   }
1578
1579   // Make sure that our non-designated initializer list has space
1580   // for a subobject corresponding to this array element.
1581   if (DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
1582     StructuredList->resizeInits(SemaRef.Context,
1583                                 DesignatedEndIndex.getZExtValue() + 1);
1584
1585   // Repeatedly perform subobject initializations in the range
1586   // [DesignatedStartIndex, DesignatedEndIndex].
1587
1588   // Move to the next designator
1589   unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
1590   unsigned OldIndex = Index;
1591
1592   InitializedEntity ElementEntity =
1593     InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1594
1595   while (DesignatedStartIndex <= DesignatedEndIndex) {
1596     // Recurse to check later designated subobjects.
1597     QualType ElementType = AT->getElementType();
1598     Index = OldIndex;
1599
1600     ElementEntity.setElementIndex(ElementIndex);
1601     if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1,
1602                                    ElementType, 0, 0, Index,
1603                                    StructuredList, ElementIndex,
1604                                    (DesignatedStartIndex == DesignatedEndIndex),
1605                                    false))
1606       return true;
1607
1608     // Move to the next index in the array that we'll be initializing.
1609     ++DesignatedStartIndex;
1610     ElementIndex = DesignatedStartIndex.getZExtValue();
1611   }
1612
1613   // If this the first designator, our caller will continue checking
1614   // the rest of this array subobject.
1615   if (IsFirstDesignator) {
1616     if (NextElementIndex)
1617       *NextElementIndex = DesignatedStartIndex;
1618     StructuredIndex = ElementIndex;
1619     return false;
1620   }
1621
1622   if (!FinishSubobjectInit)
1623     return false;
1624
1625   // Check the remaining elements within this array subobject.
1626   bool prevHadError = hadError;
1627   CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
1628                  /*SubobjectIsDesignatorContext=*/false, Index,
1629                  StructuredList, ElementIndex);
1630   return hadError && !prevHadError;
1631 }
1632
1633 // Get the structured initializer list for a subobject of type
1634 // @p CurrentObjectType.
1635 InitListExpr *
1636 InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
1637                                             QualType CurrentObjectType,
1638                                             InitListExpr *StructuredList,
1639                                             unsigned StructuredIndex,
1640                                             SourceRange InitRange) {
1641   Expr *ExistingInit = 0;
1642   if (!StructuredList)
1643     ExistingInit = SyntacticToSemantic[IList];
1644   else if (StructuredIndex < StructuredList->getNumInits())
1645     ExistingInit = StructuredList->getInit(StructuredIndex);
1646
1647   if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
1648     return Result;
1649
1650   if (ExistingInit) {
1651     // We are creating an initializer list that initializes the
1652     // subobjects of the current object, but there was already an
1653     // initialization that completely initialized the current
1654     // subobject, e.g., by a compound literal:
1655     //
1656     // struct X { int a, b; };
1657     // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
1658     //
1659     // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
1660     // designated initializer re-initializes the whole
1661     // subobject [0], overwriting previous initializers.
1662     SemaRef.Diag(InitRange.getBegin(),
1663                  diag::warn_subobject_initializer_overrides)
1664       << InitRange;
1665     SemaRef.Diag(ExistingInit->getSourceRange().getBegin(),
1666                   diag::note_previous_initializer)
1667       << /*FIXME:has side effects=*/0
1668       << ExistingInit->getSourceRange();
1669   }
1670
1671   InitListExpr *Result
1672     = new (SemaRef.Context) InitListExpr(InitRange.getBegin(), 0, 0,
1673                                          InitRange.getEnd());
1674
1675   Result->setType(CurrentObjectType.getNonReferenceType());
1676
1677   // Pre-allocate storage for the structured initializer list.
1678   unsigned NumElements = 0;
1679   unsigned NumInits = 0;
1680   if (!StructuredList)
1681     NumInits = IList->getNumInits();
1682   else if (Index < IList->getNumInits()) {
1683     if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index)))
1684       NumInits = SubList->getNumInits();
1685   }
1686
1687   if (const ArrayType *AType
1688       = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
1689     if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
1690       NumElements = CAType->getSize().getZExtValue();
1691       // Simple heuristic so that we don't allocate a very large
1692       // initializer with many empty entries at the end.
1693       if (NumInits && NumElements > NumInits)
1694         NumElements = 0;
1695     }
1696   } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
1697     NumElements = VType->getNumElements();
1698   else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
1699     RecordDecl *RDecl = RType->getDecl();
1700     if (RDecl->isUnion())
1701       NumElements = 1;
1702     else
1703       NumElements = std::distance(RDecl->field_begin(),
1704                                   RDecl->field_end());
1705   }
1706
1707   if (NumElements < NumInits)
1708     NumElements = IList->getNumInits();
1709
1710   Result->reserveInits(NumElements);
1711
1712   // Link this new initializer list into the structured initializer
1713   // lists.
1714   if (StructuredList)
1715     StructuredList->updateInit(StructuredIndex, Result);
1716   else {
1717     Result->setSyntacticForm(IList);
1718     SyntacticToSemantic[IList] = Result;
1719   }
1720
1721   return Result;
1722 }
1723
1724 /// Update the initializer at index @p StructuredIndex within the
1725 /// structured initializer list to the value @p expr.
1726 void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
1727                                                   unsigned &StructuredIndex,
1728                                                   Expr *expr) {
1729   // No structured initializer list to update
1730   if (!StructuredList)
1731     return;
1732
1733   if (Expr *PrevInit = StructuredList->updateInit(StructuredIndex, expr)) {
1734     // This initializer overwrites a previous initializer. Warn.
1735     SemaRef.Diag(expr->getSourceRange().getBegin(),
1736                   diag::warn_initializer_overrides)
1737       << expr->getSourceRange();
1738     SemaRef.Diag(PrevInit->getSourceRange().getBegin(),
1739                   diag::note_previous_initializer)
1740       << /*FIXME:has side effects=*/0
1741       << PrevInit->getSourceRange();
1742   }
1743
1744   ++StructuredIndex;
1745 }
1746
1747 /// Check that the given Index expression is a valid array designator
1748 /// value. This is essentailly just a wrapper around
1749 /// VerifyIntegerConstantExpression that also checks for negative values
1750 /// and produces a reasonable diagnostic if there is a
1751 /// failure. Returns true if there was an error, false otherwise.  If
1752 /// everything went okay, Value will receive the value of the constant
1753 /// expression.
1754 static bool
1755 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
1756   SourceLocation Loc = Index->getSourceRange().getBegin();
1757
1758   // Make sure this is an integer constant expression.
1759   if (S.VerifyIntegerConstantExpression(Index, &Value))
1760     return true;
1761
1762   if (Value.isSigned() && Value.isNegative())
1763     return S.Diag(Loc, diag::err_array_designator_negative)
1764       << Value.toString(10) << Index->getSourceRange();
1765
1766   Value.setIsUnsigned(true);
1767   return false;
1768 }
1769
1770 Sema::OwningExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
1771                                                         SourceLocation Loc,
1772                                                         bool GNUSyntax,
1773                                                         OwningExprResult Init) {
1774   typedef DesignatedInitExpr::Designator ASTDesignator;
1775
1776   bool Invalid = false;
1777   llvm::SmallVector<ASTDesignator, 32> Designators;
1778   llvm::SmallVector<Expr *, 32> InitExpressions;
1779
1780   // Build designators and check array designator expressions.
1781   for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
1782     const Designator &D = Desig.getDesignator(Idx);
1783     switch (D.getKind()) {
1784     case Designator::FieldDesignator:
1785       Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
1786                                           D.getFieldLoc()));
1787       break;
1788
1789     case Designator::ArrayDesignator: {
1790       Expr *Index = static_cast<Expr *>(D.getArrayIndex());
1791       llvm::APSInt IndexValue;
1792       if (!Index->isTypeDependent() &&
1793           !Index->isValueDependent() &&
1794           CheckArrayDesignatorExpr(*this, Index, IndexValue))
1795         Invalid = true;
1796       else {
1797         Designators.push_back(ASTDesignator(InitExpressions.size(),
1798                                             D.getLBracketLoc(),
1799                                             D.getRBracketLoc()));
1800         InitExpressions.push_back(Index);
1801       }
1802       break;
1803     }
1804
1805     case Designator::ArrayRangeDesignator: {
1806       Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
1807       Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
1808       llvm::APSInt StartValue;
1809       llvm::APSInt EndValue;
1810       bool StartDependent = StartIndex->isTypeDependent() ||
1811                             StartIndex->isValueDependent();
1812       bool EndDependent = EndIndex->isTypeDependent() ||
1813                           EndIndex->isValueDependent();
1814       if ((!StartDependent &&
1815            CheckArrayDesignatorExpr(*this, StartIndex, StartValue)) ||
1816           (!EndDependent &&
1817            CheckArrayDesignatorExpr(*this, EndIndex, EndValue)))
1818         Invalid = true;
1819       else {
1820         // Make sure we're comparing values with the same bit width.
1821         if (StartDependent || EndDependent) {
1822           // Nothing to compute.
1823         } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
1824           EndValue.extend(StartValue.getBitWidth());
1825         else if (StartValue.getBitWidth() < EndValue.getBitWidth())
1826           StartValue.extend(EndValue.getBitWidth());
1827
1828         if (!StartDependent && !EndDependent && EndValue < StartValue) {
1829           Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
1830             << StartValue.toString(10) << EndValue.toString(10)
1831             << StartIndex->getSourceRange() << EndIndex->getSourceRange();
1832           Invalid = true;
1833         } else {
1834           Designators.push_back(ASTDesignator(InitExpressions.size(),
1835                                               D.getLBracketLoc(),
1836                                               D.getEllipsisLoc(),
1837                                               D.getRBracketLoc()));
1838           InitExpressions.push_back(StartIndex);
1839           InitExpressions.push_back(EndIndex);
1840         }
1841       }
1842       break;
1843     }
1844     }
1845   }
1846
1847   if (Invalid || Init.isInvalid())
1848     return ExprError();
1849
1850   // Clear out the expressions within the designation.
1851   Desig.ClearExprs(*this);
1852
1853   DesignatedInitExpr *DIE
1854     = DesignatedInitExpr::Create(Context,
1855                                  Designators.data(), Designators.size(),
1856                                  InitExpressions.data(), InitExpressions.size(),
1857                                  Loc, GNUSyntax, Init.takeAs<Expr>());
1858   return Owned(DIE);
1859 }
1860
1861 bool Sema::CheckInitList(const InitializedEntity &Entity,
1862                          InitListExpr *&InitList, QualType &DeclType) {
1863   InitListChecker CheckInitList(*this, Entity, InitList, DeclType);
1864   if (!CheckInitList.HadError())
1865     InitList = CheckInitList.getFullyStructuredList();
1866
1867   return CheckInitList.HadError();
1868 }
1869
1870 //===----------------------------------------------------------------------===//
1871 // Initialization entity
1872 //===----------------------------------------------------------------------===//
1873
1874 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
1875                                      const InitializedEntity &Parent)
1876   : Parent(&Parent), Index(Index)
1877 {
1878   if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
1879     Kind = EK_ArrayElement;
1880     Type = AT->getElementType();
1881   } else {
1882     Kind = EK_VectorElement;
1883     Type = Parent.getType()->getAs<VectorType>()->getElementType();
1884   }
1885 }
1886
1887 InitializedEntity InitializedEntity::InitializeBase(ASTContext &Context,
1888                                                     CXXBaseSpecifier *Base)
1889 {
1890   InitializedEntity Result;
1891   Result.Kind = EK_Base;
1892   Result.Base = Base;
1893   Result.Type = Base->getType();
1894   return Result;
1895 }
1896
1897 DeclarationName InitializedEntity::getName() const {
1898   switch (getKind()) {
1899   case EK_Parameter:
1900     if (!VariableOrMember)
1901       return DeclarationName();
1902     // Fall through
1903
1904   case EK_Variable:
1905   case EK_Member:
1906     return VariableOrMember->getDeclName();
1907
1908   case EK_Result:
1909   case EK_Exception:
1910   case EK_New:
1911   case EK_Temporary:
1912   case EK_Base:
1913   case EK_ArrayElement:
1914   case EK_VectorElement:
1915     return DeclarationName();
1916   }
1917
1918   // Silence GCC warning
1919   return DeclarationName();
1920 }
1921
1922 DeclaratorDecl *InitializedEntity::getDecl() const {
1923   switch (getKind()) {
1924   case EK_Variable:
1925   case EK_Parameter:
1926   case EK_Member:
1927     return VariableOrMember;
1928
1929   case EK_Result:
1930   case EK_Exception:
1931   case EK_New:
1932   case EK_Temporary:
1933   case EK_Base:
1934   case EK_ArrayElement:
1935   case EK_VectorElement:
1936     return 0;
1937   }
1938
1939   // Silence GCC warning
1940   return 0;
1941 }
1942
1943 //===----------------------------------------------------------------------===//
1944 // Initialization sequence
1945 //===----------------------------------------------------------------------===//
1946
1947 void InitializationSequence::Step::Destroy() {
1948   switch (Kind) {
1949   case SK_ResolveAddressOfOverloadedFunction:
1950   case SK_CastDerivedToBaseRValue:
1951   case SK_CastDerivedToBaseLValue:
1952   case SK_BindReference:
1953   case SK_BindReferenceToTemporary:
1954   case SK_UserConversion:
1955   case SK_QualificationConversionRValue:
1956   case SK_QualificationConversionLValue:
1957   case SK_ListInitialization:
1958   case SK_ConstructorInitialization:
1959   case SK_ZeroInitialization:
1960   case SK_CAssignment:
1961   case SK_StringInit:
1962     break;
1963
1964   case SK_ConversionSequence:
1965     delete ICS;
1966   }
1967 }
1968
1969 void InitializationSequence::AddAddressOverloadResolutionStep(
1970                                                       FunctionDecl *Function) {
1971   Step S;
1972   S.Kind = SK_ResolveAddressOfOverloadedFunction;
1973   S.Type = Function->getType();
1974   // Access is currently ignored for these.
1975   S.Function = DeclAccessPair::make(Function, AccessSpecifier(0));
1976   Steps.push_back(S);
1977 }
1978
1979 void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
1980                                                       bool IsLValue) {
1981   Step S;
1982   S.Kind = IsLValue? SK_CastDerivedToBaseLValue : SK_CastDerivedToBaseRValue;
1983   S.Type = BaseType;
1984   Steps.push_back(S);
1985 }
1986
1987 void InitializationSequence::AddReferenceBindingStep(QualType T,
1988                                                      bool BindingTemporary) {
1989   Step S;
1990   S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
1991   S.Type = T;
1992   Steps.push_back(S);
1993 }
1994
1995 void InitializationSequence::AddUserConversionStep(FunctionDecl *Function,
1996                                                    AccessSpecifier Access,
1997                                                    QualType T) {
1998   Step S;
1999   S.Kind = SK_UserConversion;
2000   S.Type = T;
2001   S.Function = DeclAccessPair::make(Function, Access);
2002   Steps.push_back(S);
2003 }
2004
2005 void InitializationSequence::AddQualificationConversionStep(QualType Ty,
2006                                                             bool IsLValue) {
2007   Step S;
2008   S.Kind = IsLValue? SK_QualificationConversionLValue
2009                    : SK_QualificationConversionRValue;
2010   S.Type = Ty;
2011   Steps.push_back(S);
2012 }
2013
2014 void InitializationSequence::AddConversionSequenceStep(
2015                                        const ImplicitConversionSequence &ICS,
2016                                                        QualType T) {
2017   Step S;
2018   S.Kind = SK_ConversionSequence;
2019   S.Type = T;
2020   S.ICS = new ImplicitConversionSequence(ICS);
2021   Steps.push_back(S);
2022 }
2023
2024 void InitializationSequence::AddListInitializationStep(QualType T) {
2025   Step S;
2026   S.Kind = SK_ListInitialization;
2027   S.Type = T;
2028   Steps.push_back(S);
2029 }
2030
2031 void
2032 InitializationSequence::AddConstructorInitializationStep(
2033                                               CXXConstructorDecl *Constructor,
2034                                                        AccessSpecifier Access,
2035                                                          QualType T) {
2036   Step S;
2037   S.Kind = SK_ConstructorInitialization;
2038   S.Type = T;
2039   S.Function = DeclAccessPair::make(Constructor, Access);
2040   Steps.push_back(S);
2041 }
2042
2043 void InitializationSequence::AddZeroInitializationStep(QualType T) {
2044   Step S;
2045   S.Kind = SK_ZeroInitialization;
2046   S.Type = T;
2047   Steps.push_back(S);
2048 }
2049
2050 void InitializationSequence::AddCAssignmentStep(QualType T) {
2051   Step S;
2052   S.Kind = SK_CAssignment;
2053   S.Type = T;
2054   Steps.push_back(S);
2055 }
2056
2057 void InitializationSequence::AddStringInitStep(QualType T) {
2058   Step S;
2059   S.Kind = SK_StringInit;
2060   S.Type = T;
2061   Steps.push_back(S);
2062 }
2063
2064 void InitializationSequence::SetOverloadFailure(FailureKind Failure,
2065                                                 OverloadingResult Result) {
2066   SequenceKind = FailedSequence;
2067   this->Failure = Failure;
2068   this->FailedOverloadResult = Result;
2069 }
2070
2071 //===----------------------------------------------------------------------===//
2072 // Attempt initialization
2073 //===----------------------------------------------------------------------===//
2074
2075 /// \brief Attempt list initialization (C++0x [dcl.init.list])
2076 static void TryListInitialization(Sema &S,
2077                                   const InitializedEntity &Entity,
2078                                   const InitializationKind &Kind,
2079                                   InitListExpr *InitList,
2080                                   InitializationSequence &Sequence) {
2081   // FIXME: We only perform rudimentary checking of list
2082   // initializations at this point, then assume that any list
2083   // initialization of an array, aggregate, or scalar will be
2084   // well-formed. We we actually "perform" list initialization, we'll
2085   // do all of the necessary checking.  C++0x initializer lists will
2086   // force us to perform more checking here.
2087   Sequence.setSequenceKind(InitializationSequence::ListInitialization);
2088
2089   QualType DestType = Entity.getType();
2090
2091   // C++ [dcl.init]p13:
2092   //   If T is a scalar type, then a declaration of the form
2093   //
2094   //     T x = { a };
2095   //
2096   //   is equivalent to
2097   //
2098   //     T x = a;
2099   if (DestType->isScalarType()) {
2100     if (InitList->getNumInits() > 1 && S.getLangOptions().CPlusPlus) {
2101       Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar);
2102       return;
2103     }
2104
2105     // Assume scalar initialization from a single value works.
2106   } else if (DestType->isAggregateType()) {
2107     // Assume aggregate initialization works.
2108   } else if (DestType->isVectorType()) {
2109     // Assume vector initialization works.
2110   } else if (DestType->isReferenceType()) {
2111     // FIXME: C++0x defines behavior for this.
2112     Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
2113     return;
2114   } else if (DestType->isRecordType()) {
2115     // FIXME: C++0x defines behavior for this
2116     Sequence.SetFailed(InitializationSequence::FK_InitListBadDestinationType);
2117   }
2118
2119   // Add a general "list initialization" step.
2120   Sequence.AddListInitializationStep(DestType);
2121 }
2122
2123 /// \brief Try a reference initialization that involves calling a conversion
2124 /// function.
2125 ///
2126 /// FIXME: look intos DRs 656, 896
2127 static OverloadingResult TryRefInitWithConversionFunction(Sema &S,
2128                                              const InitializedEntity &Entity,
2129                                              const InitializationKind &Kind,
2130                                                           Expr *Initializer,
2131                                                           bool AllowRValues,
2132                                              InitializationSequence &Sequence) {
2133   QualType DestType = Entity.getType();
2134   QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
2135   QualType T1 = cv1T1.getUnqualifiedType();
2136   QualType cv2T2 = Initializer->getType();
2137   QualType T2 = cv2T2.getUnqualifiedType();
2138
2139   bool DerivedToBase;
2140   assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
2141                                          T1, T2, DerivedToBase) &&
2142          "Must have incompatible references when binding via conversion");
2143   (void)DerivedToBase;
2144
2145   // Build the candidate set directly in the initialization sequence
2146   // structure, so that it will persist if we fail.
2147   OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
2148   CandidateSet.clear();
2149
2150   // Determine whether we are allowed to call explicit constructors or
2151   // explicit conversion operators.
2152   bool AllowExplicit = Kind.getKind() == InitializationKind::IK_Direct;
2153
2154   const RecordType *T1RecordType = 0;
2155   if (AllowRValues && (T1RecordType = T1->getAs<RecordType>())) {
2156     // The type we're converting to is a class type. Enumerate its constructors
2157     // to see if there is a suitable conversion.
2158     CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
2159
2160     DeclarationName ConstructorName
2161       = S.Context.DeclarationNames.getCXXConstructorName(
2162                            S.Context.getCanonicalType(T1).getUnqualifiedType());
2163     DeclContext::lookup_iterator Con, ConEnd;
2164     for (llvm::tie(Con, ConEnd) = T1RecordDecl->lookup(ConstructorName);
2165          Con != ConEnd; ++Con) {
2166       // Find the constructor (which may be a template).
2167       CXXConstructorDecl *Constructor = 0;
2168       FunctionTemplateDecl *ConstructorTmpl
2169         = dyn_cast<FunctionTemplateDecl>(*Con);
2170       if (ConstructorTmpl)
2171         Constructor = cast<CXXConstructorDecl>(
2172                                          ConstructorTmpl->getTemplatedDecl());
2173       else
2174         Constructor = cast<CXXConstructorDecl>(*Con);
2175
2176       if (!Constructor->isInvalidDecl() &&
2177           Constructor->isConvertingConstructor(AllowExplicit)) {
2178         if (ConstructorTmpl)
2179           S.AddTemplateOverloadCandidate(ConstructorTmpl,
2180                                          ConstructorTmpl->getAccess(),
2181                                          /*ExplicitArgs*/ 0,
2182                                          &Initializer, 1, CandidateSet);
2183         else
2184           S.AddOverloadCandidate(Constructor, Constructor->getAccess(),
2185                                  &Initializer, 1, CandidateSet);
2186       }
2187     }
2188   }
2189
2190   if (const RecordType *T2RecordType = T2->getAs<RecordType>()) {
2191     // The type we're converting from is a class type, enumerate its conversion
2192     // functions.
2193     CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
2194
2195     // Determine the type we are converting to. If we are allowed to
2196     // convert to an rvalue, take the type that the destination type
2197     // refers to.
2198     QualType ToType = AllowRValues? cv1T1 : DestType;
2199
2200     const UnresolvedSetImpl *Conversions
2201       = T2RecordDecl->getVisibleConversionFunctions();
2202     for (UnresolvedSetImpl::const_iterator I = Conversions->begin(),
2203            E = Conversions->end(); I != E; ++I) {
2204       NamedDecl *D = *I;
2205       CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
2206       if (isa<UsingShadowDecl>(D))
2207         D = cast<UsingShadowDecl>(D)->getTargetDecl();
2208
2209       FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
2210       CXXConversionDecl *Conv;
2211       if (ConvTemplate)
2212         Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
2213       else
2214         Conv = cast<CXXConversionDecl>(*I);
2215
2216       // If the conversion function doesn't return a reference type,
2217       // it can't be considered for this conversion unless we're allowed to
2218       // consider rvalues.
2219       // FIXME: Do we need to make sure that we only consider conversion
2220       // candidates with reference-compatible results? That might be needed to
2221       // break recursion.
2222       if ((AllowExplicit || !Conv->isExplicit()) &&
2223           (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
2224         if (ConvTemplate)
2225           S.AddTemplateConversionCandidate(ConvTemplate, I.getAccess(),
2226                                            ActingDC, Initializer,
2227                                            ToType, CandidateSet);
2228         else
2229           S.AddConversionCandidate(Conv, I.getAccess(), ActingDC,
2230                                    Initializer, cv1T1, CandidateSet);
2231       }
2232     }
2233   }
2234
2235   SourceLocation DeclLoc = Initializer->getLocStart();
2236
2237   // Perform overload resolution. If it fails, return the failed result.
2238   OverloadCandidateSet::iterator Best;
2239   if (OverloadingResult Result
2240         = S.BestViableFunction(CandidateSet, DeclLoc, Best))
2241     return Result;
2242
2243   FunctionDecl *Function = Best->Function;
2244
2245   // Compute the returned type of the conversion.
2246   if (isa<CXXConversionDecl>(Function))
2247     T2 = Function->getResultType();
2248   else
2249     T2 = cv1T1;
2250
2251   // Add the user-defined conversion step.
2252   Sequence.AddUserConversionStep(Function, Best->getAccess(),
2253                                  T2.getNonReferenceType());
2254
2255   // Determine whether we need to perform derived-to-base or
2256   // cv-qualification adjustments.
2257   bool NewDerivedToBase = false;
2258   Sema::ReferenceCompareResult NewRefRelationship
2259     = S.CompareReferenceRelationship(DeclLoc, T1, T2.getNonReferenceType(),
2260                                      NewDerivedToBase);
2261   assert(NewRefRelationship != Sema::Ref_Incompatible &&
2262          "Overload resolution picked a bad conversion function");
2263   (void)NewRefRelationship;
2264   if (NewDerivedToBase)
2265     Sequence.AddDerivedToBaseCastStep(
2266                                 S.Context.getQualifiedType(T1,
2267                                   T2.getNonReferenceType().getQualifiers()),
2268                                   /*isLValue=*/true);
2269
2270   if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers())
2271     Sequence.AddQualificationConversionStep(cv1T1, T2->isReferenceType());
2272
2273   Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType());
2274   return OR_Success;
2275 }
2276
2277 /// \brief Attempt reference initialization (C++0x [dcl.init.list])
2278 static void TryReferenceInitialization(Sema &S,
2279                                        const InitializedEntity &Entity,
2280                                        const InitializationKind &Kind,
2281                                        Expr *Initializer,
2282                                        InitializationSequence &Sequence) {
2283   Sequence.setSequenceKind(InitializationSequence::ReferenceBinding);
2284
2285   QualType DestType = Entity.getType();
2286   QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
2287   Qualifiers T1Quals;
2288   QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
2289   QualType cv2T2 = Initializer->getType();
2290   Qualifiers T2Quals;
2291   QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
2292   SourceLocation DeclLoc = Initializer->getLocStart();
2293
2294   // If the initializer is the address of an overloaded function, try
2295   // to resolve the overloaded function. If all goes well, T2 is the
2296   // type of the resulting function.
2297   if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
2298     FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Initializer,
2299                                                             T1,
2300                                                             false);
2301     if (!Fn) {
2302       Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
2303       return;
2304     }
2305
2306     Sequence.AddAddressOverloadResolutionStep(Fn);
2307     cv2T2 = Fn->getType();
2308     T2 = cv2T2.getUnqualifiedType();
2309   }
2310
2311   // FIXME: Rvalue references
2312   bool ForceRValue = false;
2313
2314   // Compute some basic properties of the types and the initializer.
2315   bool isLValueRef = DestType->isLValueReferenceType();
2316   bool isRValueRef = !isLValueRef;
2317   bool DerivedToBase = false;
2318   Expr::isLvalueResult InitLvalue = ForceRValue ? Expr::LV_InvalidExpression :
2319                                     Initializer->isLvalue(S.Context);
2320   Sema::ReferenceCompareResult RefRelationship
2321     = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase);
2322
2323   // C++0x [dcl.init.ref]p5:
2324   //   A reference to type "cv1 T1" is initialized by an expression of type
2325   //   "cv2 T2" as follows:
2326   //
2327   //     - If the reference is an lvalue reference and the initializer
2328   //       expression
2329   OverloadingResult ConvOvlResult = OR_Success;
2330   if (isLValueRef) {
2331     if (InitLvalue == Expr::LV_Valid &&
2332         RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification) {
2333       //   - is an lvalue (but is not a bit-field), and "cv1 T1" is
2334       //     reference-compatible with "cv2 T2," or
2335       //
2336       // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a
2337       // bit-field when we're determining whether the reference initialization
2338       // can occur. However, we do pay attention to whether it is a bit-field
2339       // to decide whether we're actually binding to a temporary created from
2340       // the bit-field.
2341       if (DerivedToBase)
2342         Sequence.AddDerivedToBaseCastStep(
2343                          S.Context.getQualifiedType(T1, T2Quals),
2344                          /*isLValue=*/true);
2345       if (T1Quals != T2Quals)
2346         Sequence.AddQualificationConversionStep(cv1T1, /*IsLValue=*/true);
2347       bool BindingTemporary = T1Quals.hasConst() && !T1Quals.hasVolatile() &&
2348         (Initializer->getBitField() || Initializer->refersToVectorElement());
2349       Sequence.AddReferenceBindingStep(cv1T1, BindingTemporary);
2350       return;
2351     }
2352
2353     //     - has a class type (i.e., T2 is a class type), where T1 is not
2354     //       reference-related to T2, and can be implicitly converted to an
2355     //       lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
2356     //       with "cv3 T3" (this conversion is selected by enumerating the
2357     //       applicable conversion functions (13.3.1.6) and choosing the best
2358     //       one through overload resolution (13.3)),
2359     if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType()) {
2360       ConvOvlResult = TryRefInitWithConversionFunction(S, Entity, Kind,
2361                                                        Initializer,
2362                                                        /*AllowRValues=*/false,
2363                                                        Sequence);
2364       if (ConvOvlResult == OR_Success)
2365         return;
2366       if (ConvOvlResult != OR_No_Viable_Function) {
2367         Sequence.SetOverloadFailure(
2368                       InitializationSequence::FK_ReferenceInitOverloadFailed,
2369                                     ConvOvlResult);
2370       }
2371     }
2372   }
2373
2374   //     - Otherwise, the reference shall be an lvalue reference to a
2375   //       non-volatile const type (i.e., cv1 shall be const), or the reference
2376   //       shall be an rvalue reference and the initializer expression shall
2377   //       be an rvalue.
2378   if (!((isLValueRef && T1Quals.hasConst() && !T1Quals.hasVolatile()) ||
2379         (isRValueRef && InitLvalue != Expr::LV_Valid))) {
2380     if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
2381       Sequence.SetOverloadFailure(
2382                         InitializationSequence::FK_ReferenceInitOverloadFailed,
2383                                   ConvOvlResult);
2384     else if (isLValueRef)
2385       Sequence.SetFailed(InitLvalue == Expr::LV_Valid
2386         ? (RefRelationship == Sema::Ref_Related
2387              ? InitializationSequence::FK_ReferenceInitDropsQualifiers
2388              : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated)
2389         : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
2390     else
2391       Sequence.SetFailed(
2392                     InitializationSequence::FK_RValueReferenceBindingToLValue);
2393
2394     return;
2395   }
2396
2397   //       - If T1 and T2 are class types and
2398   if (T1->isRecordType() && T2->isRecordType()) {
2399     //       - the initializer expression is an rvalue and "cv1 T1" is
2400     //         reference-compatible with "cv2 T2", or
2401     if (InitLvalue != Expr::LV_Valid &&
2402         RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification) {
2403       if (DerivedToBase)
2404         Sequence.AddDerivedToBaseCastStep(
2405                          S.Context.getQualifiedType(T1, T2Quals),
2406                          /*isLValue=*/false);
2407       if (T1Quals != T2Quals)
2408         Sequence.AddQualificationConversionStep(cv1T1, /*IsLValue=*/false);
2409       Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
2410       return;
2411     }
2412
2413     //       - T1 is not reference-related to T2 and the initializer expression
2414     //         can be implicitly converted to an rvalue of type "cv3 T3" (this
2415     //         conversion is selected by enumerating the applicable conversion
2416     //         functions (13.3.1.6) and choosing the best one through overload
2417     //         resolution (13.3)),
2418     if (RefRelationship == Sema::Ref_Incompatible) {
2419       ConvOvlResult = TryRefInitWithConversionFunction(S, Entity,
2420                                                        Kind, Initializer,
2421                                                        /*AllowRValues=*/true,
2422                                                        Sequence);
2423       if (ConvOvlResult)
2424         Sequence.SetOverloadFailure(
2425                       InitializationSequence::FK_ReferenceInitOverloadFailed,
2426                                     ConvOvlResult);
2427
2428       return;
2429     }
2430
2431     Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
2432     return;
2433   }
2434
2435   //      - If the initializer expression is an rvalue, with T2 an array type,
2436   //        and "cv1 T1" is reference-compatible with "cv2 T2," the reference
2437   //        is bound to the object represented by the rvalue (see 3.10).
2438   // FIXME: How can an array type be reference-compatible with anything?
2439   // Don't we mean the element types of T1 and T2?
2440
2441   //      - Otherwise, a temporary of type “cv1 T1” is created and initialized
2442   //        from the initializer expression using the rules for a non-reference
2443   //        copy initialization (8.5). The reference is then bound to the
2444   //        temporary. [...]
2445   // Determine whether we are allowed to call explicit constructors or
2446   // explicit conversion operators.
2447   bool AllowExplicit = (Kind.getKind() == InitializationKind::IK_Direct);
2448   ImplicitConversionSequence ICS
2449     = S.TryImplicitConversion(Initializer, cv1T1,
2450                               /*SuppressUserConversions=*/false, AllowExplicit,
2451                               /*ForceRValue=*/false,
2452                               /*FIXME:InOverloadResolution=*/false,
2453                               /*UserCast=*/Kind.isExplicitCast());
2454
2455   if (ICS.isBad()) {
2456     // FIXME: Use the conversion function set stored in ICS to turn
2457     // this into an overloading ambiguity diagnostic. However, we need
2458     // to keep that set as an OverloadCandidateSet rather than as some
2459     // other kind of set.
2460     if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
2461       Sequence.SetOverloadFailure(
2462                         InitializationSequence::FK_ReferenceInitOverloadFailed,
2463                                   ConvOvlResult);
2464     else
2465       Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed);
2466     return;
2467   }
2468
2469   //        [...] If T1 is reference-related to T2, cv1 must be the
2470   //        same cv-qualification as, or greater cv-qualification
2471   //        than, cv2; otherwise, the program is ill-formed.
2472   unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
2473   unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
2474   if (RefRelationship == Sema::Ref_Related &&
2475       (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
2476     Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
2477     return;
2478   }
2479
2480   // Perform the actual conversion.
2481   Sequence.AddConversionSequenceStep(ICS, cv1T1);
2482   Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
2483   return;
2484 }
2485
2486 /// \brief Attempt character array initialization from a string literal
2487 /// (C++ [dcl.init.string], C99 6.7.8).
2488 static void TryStringLiteralInitialization(Sema &S,
2489                                            const InitializedEntity &Entity,
2490                                            const InitializationKind &Kind,
2491                                            Expr *Initializer,
2492                                        InitializationSequence &Sequence) {
2493   Sequence.setSequenceKind(InitializationSequence::StringInit);
2494   Sequence.AddStringInitStep(Entity.getType());
2495 }
2496
2497 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which
2498 /// enumerates the constructors of the initialized entity and performs overload
2499 /// resolution to select the best.
2500 static void TryConstructorInitialization(Sema &S,
2501                                          const InitializedEntity &Entity,
2502                                          const InitializationKind &Kind,
2503                                          Expr **Args, unsigned NumArgs,
2504                                          QualType DestType,
2505                                          InitializationSequence &Sequence) {
2506   if (Kind.getKind() == InitializationKind::IK_Copy)
2507     Sequence.setSequenceKind(InitializationSequence::UserDefinedConversion);
2508   else
2509     Sequence.setSequenceKind(InitializationSequence::ConstructorInitialization);
2510
2511   // Build the candidate set directly in the initialization sequence
2512   // structure, so that it will persist if we fail.
2513   OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
2514   CandidateSet.clear();
2515
2516   // Determine whether we are allowed to call explicit constructors or
2517   // explicit conversion operators.
2518   bool AllowExplicit = (Kind.getKind() == InitializationKind::IK_Direct ||
2519                         Kind.getKind() == InitializationKind::IK_Value ||
2520                         Kind.getKind() == InitializationKind::IK_Default);
2521
2522   // The type we're converting to is a class type. Enumerate its constructors
2523   // to see if one is suitable.
2524   const RecordType *DestRecordType = DestType->getAs<RecordType>();
2525   assert(DestRecordType && "Constructor initialization requires record type");
2526   CXXRecordDecl *DestRecordDecl
2527     = cast<CXXRecordDecl>(DestRecordType->getDecl());
2528
2529   DeclarationName ConstructorName
2530     = S.Context.DeclarationNames.getCXXConstructorName(
2531                      S.Context.getCanonicalType(DestType).getUnqualifiedType());
2532   DeclContext::lookup_iterator Con, ConEnd;
2533   for (llvm::tie(Con, ConEnd) = DestRecordDecl->lookup(ConstructorName);
2534        Con != ConEnd; ++Con) {
2535     // Find the constructor (which may be a template).
2536     CXXConstructorDecl *Constructor = 0;
2537     FunctionTemplateDecl *ConstructorTmpl
2538       = dyn_cast<FunctionTemplateDecl>(*Con);
2539     if (ConstructorTmpl)
2540       Constructor = cast<CXXConstructorDecl>(
2541                                            ConstructorTmpl->getTemplatedDecl());
2542     else
2543       Constructor = cast<CXXConstructorDecl>(*Con);
2544
2545     if (!Constructor->isInvalidDecl() &&
2546         (AllowExplicit || !Constructor->isExplicit())) {
2547       if (ConstructorTmpl)
2548         S.AddTemplateOverloadCandidate(ConstructorTmpl,
2549                                        ConstructorTmpl->getAccess(),
2550                                        /*ExplicitArgs*/ 0,
2551                                        Args, NumArgs, CandidateSet);
2552       else
2553         S.AddOverloadCandidate(Constructor, Constructor->getAccess(),
2554                                Args, NumArgs, CandidateSet);
2555     }
2556   }
2557
2558   SourceLocation DeclLoc = Kind.getLocation();
2559
2560   // Perform overload resolution. If it fails, return the failed result.
2561   OverloadCandidateSet::iterator Best;
2562   if (OverloadingResult Result
2563         = S.BestViableFunction(CandidateSet, DeclLoc, Best)) {
2564     Sequence.SetOverloadFailure(
2565                           InitializationSequence::FK_ConstructorOverloadFailed,
2566                                 Result);
2567     return;
2568   }
2569
2570   // C++0x [dcl.init]p6:
2571   //   If a program calls for the default initialization of an object
2572   //   of a const-qualified type T, T shall be a class type with a
2573   //   user-provided default constructor.
2574   if (Kind.getKind() == InitializationKind::IK_Default &&
2575       Entity.getType().isConstQualified() &&
2576       cast<CXXConstructorDecl>(Best->Function)->isImplicit()) {
2577     Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
2578     return;
2579   }
2580
2581   // Add the constructor initialization step. Any cv-qualification conversion is
2582   // subsumed by the initialization.
2583   if (Kind.getKind() == InitializationKind::IK_Copy) {
2584     Sequence.AddUserConversionStep(Best->Function, Best->getAccess(), DestType);
2585   } else {
2586     Sequence.AddConstructorInitializationStep(
2587                                       cast<CXXConstructorDecl>(Best->Function),
2588                                       Best->getAccess(),
2589                                       DestType);
2590   }
2591 }
2592
2593 /// \brief Attempt value initialization (C++ [dcl.init]p7).
2594 static void TryValueInitialization(Sema &S,
2595                                    const InitializedEntity &Entity,
2596                                    const InitializationKind &Kind,
2597                                    InitializationSequence &Sequence) {
2598   // C++ [dcl.init]p5:
2599   //
2600   //   To value-initialize an object of type T means:
2601   QualType T = Entity.getType();
2602
2603   //     -- if T is an array type, then each element is value-initialized;
2604   while (const ArrayType *AT = S.Context.getAsArrayType(T))
2605     T = AT->getElementType();
2606
2607   if (const RecordType *RT = T->getAs<RecordType>()) {
2608     if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2609       // -- if T is a class type (clause 9) with a user-declared
2610       //    constructor (12.1), then the default constructor for T is
2611       //    called (and the initialization is ill-formed if T has no
2612       //    accessible default constructor);
2613       //
2614       // FIXME: we really want to refer to a single subobject of the array,
2615       // but Entity doesn't have a way to capture that (yet).
2616       if (ClassDecl->hasUserDeclaredConstructor())
2617         return TryConstructorInitialization(S, Entity, Kind, 0, 0, T, Sequence);
2618
2619       // -- if T is a (possibly cv-qualified) non-union class type
2620       //    without a user-provided constructor, then the object is
2621       //    zero-initialized and, if T’s implicitly-declared default
2622       //    constructor is non-trivial, that constructor is called.
2623       if ((ClassDecl->getTagKind() == TagDecl::TK_class ||
2624            ClassDecl->getTagKind() == TagDecl::TK_struct) &&
2625           !ClassDecl->hasTrivialConstructor()) {
2626         Sequence.AddZeroInitializationStep(Entity.getType());
2627         return TryConstructorInitialization(S, Entity, Kind, 0, 0, T, Sequence);
2628       }
2629     }
2630   }
2631
2632   Sequence.AddZeroInitializationStep(Entity.getType());
2633   Sequence.setSequenceKind(InitializationSequence::ZeroInitialization);
2634 }
2635
2636 /// \brief Attempt default initialization (C++ [dcl.init]p6).
2637 static void TryDefaultInitialization(Sema &S,
2638                                      const InitializedEntity &Entity,
2639                                      const InitializationKind &Kind,
2640                                      InitializationSequence &Sequence) {
2641   assert(Kind.getKind() == InitializationKind::IK_Default);
2642
2643   // C++ [dcl.init]p6:
2644   //   To default-initialize an object of type T means:
2645   //     - if T is an array type, each element is default-initialized;
2646   QualType DestType = Entity.getType();
2647   while (const ArrayType *Array = S.Context.getAsArrayType(DestType))
2648     DestType = Array->getElementType();
2649
2650   //     - if T is a (possibly cv-qualified) class type (Clause 9), the default
2651   //       constructor for T is called (and the initialization is ill-formed if
2652   //       T has no accessible default constructor);
2653   if (DestType->isRecordType() && S.getLangOptions().CPlusPlus) {
2654     return TryConstructorInitialization(S, Entity, Kind, 0, 0, DestType,
2655                                         Sequence);
2656   }
2657
2658   //     - otherwise, no initialization is performed.
2659   Sequence.setSequenceKind(InitializationSequence::NoInitialization);
2660
2661   //   If a program calls for the default initialization of an object of
2662   //   a const-qualified type T, T shall be a class type with a user-provided
2663   //   default constructor.
2664   if (DestType.isConstQualified() && S.getLangOptions().CPlusPlus)
2665     Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
2666 }
2667
2668 /// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
2669 /// which enumerates all conversion functions and performs overload resolution
2670 /// to select the best.
2671 static void TryUserDefinedConversion(Sema &S,
2672                                      const InitializedEntity &Entity,
2673                                      const InitializationKind &Kind,
2674                                      Expr *Initializer,
2675                                      InitializationSequence &Sequence) {
2676   Sequence.setSequenceKind(InitializationSequence::UserDefinedConversion);
2677
2678   QualType DestType = Entity.getType();
2679   assert(!DestType->isReferenceType() && "References are handled elsewhere");
2680   QualType SourceType = Initializer->getType();
2681   assert((DestType->isRecordType() || SourceType->isRecordType()) &&
2682          "Must have a class type to perform a user-defined conversion");
2683
2684   // Build the candidate set directly in the initialization sequence
2685   // structure, so that it will persist if we fail.
2686   OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
2687   CandidateSet.clear();
2688
2689   // Determine whether we are allowed to call explicit constructors or
2690   // explicit conversion operators.
2691   bool AllowExplicit = Kind.getKind() == InitializationKind::IK_Direct;
2692
2693   if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
2694     // The type we're converting to is a class type. Enumerate its constructors
2695     // to see if there is a suitable conversion.
2696     CXXRecordDecl *DestRecordDecl
2697       = cast<CXXRecordDecl>(DestRecordType->getDecl());
2698
2699     DeclarationName ConstructorName
2700       = S.Context.DeclarationNames.getCXXConstructorName(
2701                      S.Context.getCanonicalType(DestType).getUnqualifiedType());
2702     DeclContext::lookup_iterator Con, ConEnd;
2703     for (llvm::tie(Con, ConEnd) = DestRecordDecl->lookup(ConstructorName);
2704          Con != ConEnd; ++Con) {
2705       // Find the constructor (which may be a template).
2706       CXXConstructorDecl *Constructor = 0;
2707       FunctionTemplateDecl *ConstructorTmpl
2708         = dyn_cast<FunctionTemplateDecl>(*Con);
2709       if (ConstructorTmpl)
2710         Constructor = cast<CXXConstructorDecl>(
2711                                            ConstructorTmpl->getTemplatedDecl());
2712       else
2713         Constructor = cast<CXXConstructorDecl>(*Con);
2714
2715       if (!Constructor->isInvalidDecl() &&
2716           Constructor->isConvertingConstructor(AllowExplicit)) {
2717         if (ConstructorTmpl)
2718           S.AddTemplateOverloadCandidate(ConstructorTmpl,
2719                                          ConstructorTmpl->getAccess(),
2720                                          /*ExplicitArgs*/ 0,
2721                                          &Initializer, 1, CandidateSet);
2722         else
2723           S.AddOverloadCandidate(Constructor, Constructor->getAccess(),
2724                                  &Initializer, 1, CandidateSet);
2725       }
2726     }
2727   }
2728
2729   SourceLocation DeclLoc = Initializer->getLocStart();
2730
2731   if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
2732     // The type we're converting from is a class type, enumerate its conversion
2733     // functions.
2734
2735     // We can only enumerate the conversion functions for a complete type; if
2736     // the type isn't complete, simply skip this step.
2737     if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) {
2738       CXXRecordDecl *SourceRecordDecl
2739         = cast<CXXRecordDecl>(SourceRecordType->getDecl());
2740
2741       const UnresolvedSetImpl *Conversions
2742         = SourceRecordDecl->getVisibleConversionFunctions();
2743       for (UnresolvedSetImpl::const_iterator I = Conversions->begin(),
2744            E = Conversions->end();
2745            I != E; ++I) {
2746         NamedDecl *D = *I;
2747         CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
2748         if (isa<UsingShadowDecl>(D))
2749           D = cast<UsingShadowDecl>(D)->getTargetDecl();
2750
2751         FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
2752         CXXConversionDecl *Conv;
2753         if (ConvTemplate)
2754           Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
2755         else
2756           Conv = cast<CXXConversionDecl>(*I);
2757
2758         if (AllowExplicit || !Conv->isExplicit()) {
2759           if (ConvTemplate)
2760             S.AddTemplateConversionCandidate(ConvTemplate, I.getAccess(),
2761                                              ActingDC, Initializer, DestType,
2762                                              CandidateSet);
2763           else
2764             S.AddConversionCandidate(Conv, I.getAccess(), ActingDC,
2765                                      Initializer, DestType, CandidateSet);
2766         }
2767       }
2768     }
2769   }
2770
2771   // Perform overload resolution. If it fails, return the failed result.
2772   OverloadCandidateSet::iterator Best;
2773   if (OverloadingResult Result
2774         = S.BestViableFunction(CandidateSet, DeclLoc, Best)) {
2775     Sequence.SetOverloadFailure(
2776                         InitializationSequence::FK_UserConversionOverloadFailed,
2777                                 Result);
2778     return;
2779   }
2780
2781   FunctionDecl *Function = Best->Function;
2782
2783   if (isa<CXXConstructorDecl>(Function)) {
2784     // Add the user-defined conversion step. Any cv-qualification conversion is
2785     // subsumed by the initialization.
2786     Sequence.AddUserConversionStep(Function, Best->getAccess(), DestType);
2787     return;
2788   }
2789
2790   // Add the user-defined conversion step that calls the conversion function.
2791   QualType ConvType = Function->getResultType().getNonReferenceType();
2792   Sequence.AddUserConversionStep(Function, Best->getAccess(), ConvType);
2793
2794   // If the conversion following the call to the conversion function is
2795   // interesting, add it as a separate step.
2796   if (Best->FinalConversion.First || Best->FinalConversion.Second ||
2797       Best->FinalConversion.Third) {
2798     ImplicitConversionSequence ICS;
2799     ICS.setStandard();
2800     ICS.Standard = Best->FinalConversion;
2801     Sequence.AddConversionSequenceStep(ICS, DestType);
2802   }
2803 }
2804
2805 /// \brief Attempt an implicit conversion (C++ [conv]) converting from one
2806 /// non-class type to another.
2807 static void TryImplicitConversion(Sema &S,
2808                                   const InitializedEntity &Entity,
2809                                   const InitializationKind &Kind,
2810                                   Expr *Initializer,
2811                                   InitializationSequence &Sequence) {
2812   ImplicitConversionSequence ICS
2813     = S.TryImplicitConversion(Initializer, Entity.getType(),
2814                               /*SuppressUserConversions=*/true,
2815                               /*AllowExplicit=*/false,
2816                               /*ForceRValue=*/false,
2817                               /*FIXME:InOverloadResolution=*/false,
2818                               /*UserCast=*/Kind.isExplicitCast());
2819
2820   if (ICS.isBad()) {
2821     Sequence.SetFailed(InitializationSequence::FK_ConversionFailed);
2822     return;
2823   }
2824
2825   Sequence.AddConversionSequenceStep(ICS, Entity.getType());
2826 }
2827
2828 InitializationSequence::InitializationSequence(Sema &S,
2829                                                const InitializedEntity &Entity,
2830                                                const InitializationKind &Kind,
2831                                                Expr **Args,
2832                                                unsigned NumArgs)
2833     : FailedCandidateSet(Kind.getLocation()) {
2834   ASTContext &Context = S.Context;
2835
2836   // C++0x [dcl.init]p16:
2837   //   The semantics of initializers are as follows. The destination type is
2838   //   the type of the object or reference being initialized and the source
2839   //   type is the type of the initializer expression. The source type is not
2840   //   defined when the initializer is a braced-init-list or when it is a
2841   //   parenthesized list of expressions.
2842   QualType DestType = Entity.getType();
2843
2844   if (DestType->isDependentType() ||
2845       Expr::hasAnyTypeDependentArguments(Args, NumArgs)) {
2846     SequenceKind = DependentSequence;
2847     return;
2848   }
2849
2850   QualType SourceType;
2851   Expr *Initializer = 0;
2852   if (NumArgs == 1) {
2853     Initializer = Args[0];
2854     if (!isa<InitListExpr>(Initializer))
2855       SourceType = Initializer->getType();
2856   }
2857
2858   //     - If the initializer is a braced-init-list, the object is
2859   //       list-initialized (8.5.4).
2860   if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
2861     TryListInitialization(S, Entity, Kind, InitList, *this);
2862     return;
2863   }
2864
2865   //     - If the destination type is a reference type, see 8.5.3.
2866   if (DestType->isReferenceType()) {
2867     // C++0x [dcl.init.ref]p1:
2868     //   A variable declared to be a T& or T&&, that is, "reference to type T"
2869     //   (8.3.2), shall be initialized by an object, or function, of type T or
2870     //   by an object that can be converted into a T.
2871     // (Therefore, multiple arguments are not permitted.)
2872     if (NumArgs != 1)
2873       SetFailed(FK_TooManyInitsForReference);
2874     else
2875       TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
2876     return;
2877   }
2878
2879   //     - If the destination type is an array of characters, an array of
2880   //       char16_t, an array of char32_t, or an array of wchar_t, and the
2881   //       initializer is a string literal, see 8.5.2.
2882   if (Initializer && IsStringInit(Initializer, DestType, Context)) {
2883     TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
2884     return;
2885   }
2886
2887   //     - If the initializer is (), the object is value-initialized.
2888   if (Kind.getKind() == InitializationKind::IK_Value ||
2889       (Kind.getKind() == InitializationKind::IK_Direct && NumArgs == 0)) {
2890     TryValueInitialization(S, Entity, Kind, *this);
2891     return;
2892   }
2893
2894   // Handle default initialization.
2895   if (Kind.getKind() == InitializationKind::IK_Default){
2896     TryDefaultInitialization(S, Entity, Kind, *this);
2897     return;
2898   }
2899
2900   //     - Otherwise, if the destination type is an array, the program is
2901   //       ill-formed.
2902   if (const ArrayType *AT = Context.getAsArrayType(DestType)) {
2903     if (AT->getElementType()->isAnyCharacterType())
2904       SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
2905     else
2906       SetFailed(FK_ArrayNeedsInitList);
2907
2908     return;
2909   }
2910
2911   // Handle initialization in C
2912   if (!S.getLangOptions().CPlusPlus) {
2913     setSequenceKind(CAssignment);
2914     AddCAssignmentStep(DestType);
2915     return;
2916   }
2917
2918   //     - If the destination type is a (possibly cv-qualified) class type:
2919   if (DestType->isRecordType()) {
2920     //     - If the initialization is direct-initialization, or if it is
2921     //       copy-initialization where the cv-unqualified version of the
2922     //       source type is the same class as, or a derived class of, the
2923     //       class of the destination, constructors are considered. [...]
2924     if (Kind.getKind() == InitializationKind::IK_Direct ||
2925         (Kind.getKind() == InitializationKind::IK_Copy &&
2926          (Context.hasSameUnqualifiedType(SourceType, DestType) ||
2927           S.IsDerivedFrom(SourceType, DestType))))
2928       TryConstructorInitialization(S, Entity, Kind, Args, NumArgs,
2929                                    Entity.getType(), *this);
2930     //     - Otherwise (i.e., for the remaining copy-initialization cases),
2931     //       user-defined conversion sequences that can convert from the source
2932     //       type to the destination type or (when a conversion function is
2933     //       used) to a derived class thereof are enumerated as described in
2934     //       13.3.1.4, and the best one is chosen through overload resolution
2935     //       (13.3).
2936     else
2937       TryUserDefinedConversion(S, Entity, Kind, Initializer, *this);
2938     return;
2939   }
2940
2941   if (NumArgs > 1) {
2942     SetFailed(FK_TooManyInitsForScalar);
2943     return;
2944   }
2945   assert(NumArgs == 1 && "Zero-argument case handled above");
2946
2947   //    - Otherwise, if the source type is a (possibly cv-qualified) class
2948   //      type, conversion functions are considered.
2949   if (!SourceType.isNull() && SourceType->isRecordType()) {
2950     TryUserDefinedConversion(S, Entity, Kind, Initializer, *this);
2951     return;
2952   }
2953
2954   //    - Otherwise, the initial value of the object being initialized is the
2955   //      (possibly converted) value of the initializer expression. Standard
2956   //      conversions (Clause 4) will be used, if necessary, to convert the
2957   //      initializer expression to the cv-unqualified version of the
2958   //      destination type; no user-defined conversions are considered.
2959   setSequenceKind(StandardConversion);
2960   TryImplicitConversion(S, Entity, Kind, Initializer, *this);
2961 }
2962
2963 InitializationSequence::~InitializationSequence() {
2964   for (llvm::SmallVectorImpl<Step>::iterator Step = Steps.begin(),
2965                                           StepEnd = Steps.end();
2966        Step != StepEnd; ++Step)
2967     Step->Destroy();
2968 }
2969
2970 //===----------------------------------------------------------------------===//
2971 // Perform initialization
2972 //===----------------------------------------------------------------------===//
2973 static Sema::AssignmentAction
2974 getAssignmentAction(const InitializedEntity &Entity) {
2975   switch(Entity.getKind()) {
2976   case InitializedEntity::EK_Variable:
2977   case InitializedEntity::EK_New:
2978     return Sema::AA_Initializing;
2979
2980   case InitializedEntity::EK_Parameter:
2981     // FIXME: Can we tell when we're sending vs. passing?
2982     return Sema::AA_Passing;
2983
2984   case InitializedEntity::EK_Result:
2985     return Sema::AA_Returning;
2986
2987   case InitializedEntity::EK_Exception:
2988   case InitializedEntity::EK_Base:
2989     llvm_unreachable("No assignment action for C++-specific initialization");
2990     break;
2991
2992   case InitializedEntity::EK_Temporary:
2993     // FIXME: Can we tell apart casting vs. converting?
2994     return Sema::AA_Casting;
2995
2996   case InitializedEntity::EK_Member:
2997   case InitializedEntity::EK_ArrayElement:
2998   case InitializedEntity::EK_VectorElement:
2999     return Sema::AA_Initializing;
3000   }
3001
3002   return Sema::AA_Converting;
3003 }
3004
3005 static bool shouldBindAsTemporary(const InitializedEntity &Entity,
3006                                   bool IsCopy) {
3007   switch (Entity.getKind()) {
3008   case InitializedEntity::EK_Result:
3009   case InitializedEntity::EK_ArrayElement:
3010   case InitializedEntity::EK_Member:
3011     return !IsCopy;
3012
3013   case InitializedEntity::EK_New:
3014   case InitializedEntity::EK_Variable:
3015   case InitializedEntity::EK_Base:
3016   case InitializedEntity::EK_VectorElement:
3017   case InitializedEntity::EK_Exception:
3018     return false;
3019
3020   case InitializedEntity::EK_Parameter:
3021   case InitializedEntity::EK_Temporary:
3022     return true;
3023   }
3024
3025   llvm_unreachable("missed an InitializedEntity kind?");
3026 }
3027
3028 /// \brief If we need to perform an additional copy of the initialized object
3029 /// for this kind of entity (e.g., the result of a function or an object being
3030 /// thrown), make the copy.
3031 static Sema::OwningExprResult CopyIfRequiredForEntity(Sema &S,
3032                                             const InitializedEntity &Entity,
3033                                              const InitializationKind &Kind,
3034                                              Sema::OwningExprResult CurInit) {
3035   Expr *CurInitExpr = (Expr *)CurInit.get();
3036
3037   SourceLocation Loc;
3038
3039   switch (Entity.getKind()) {
3040   case InitializedEntity::EK_Result:
3041     if (Entity.getType()->isReferenceType())
3042       return move(CurInit);
3043     Loc = Entity.getReturnLoc();
3044     break;
3045
3046   case InitializedEntity::EK_Exception:
3047     Loc = Entity.getThrowLoc();
3048     break;
3049
3050   case InitializedEntity::EK_Variable:
3051     if (Entity.getType()->isReferenceType() ||
3052         Kind.getKind() != InitializationKind::IK_Copy)
3053       return move(CurInit);
3054     Loc = Entity.getDecl()->getLocation();
3055     break;
3056
3057   case InitializedEntity::EK_ArrayElement:
3058   case InitializedEntity::EK_Member:
3059     if (Entity.getType()->isReferenceType() ||
3060         Kind.getKind() != InitializationKind::IK_Copy)
3061       return move(CurInit);
3062     Loc = CurInitExpr->getLocStart();
3063     break;
3064
3065   case InitializedEntity::EK_Parameter:
3066     // FIXME: Do we need this initialization for a parameter?
3067     return move(CurInit);
3068
3069   case InitializedEntity::EK_New:
3070   case InitializedEntity::EK_Temporary:
3071   case InitializedEntity::EK_Base:
3072   case InitializedEntity::EK_VectorElement:
3073     // We don't need to copy for any of these initialized entities.
3074     return move(CurInit);
3075   }
3076
3077   CXXRecordDecl *Class = 0;
3078   if (const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>())
3079     Class = cast<CXXRecordDecl>(Record->getDecl());
3080   if (!Class)
3081     return move(CurInit);
3082
3083   // Perform overload resolution using the class's copy constructors.
3084   DeclarationName ConstructorName
3085     = S.Context.DeclarationNames.getCXXConstructorName(
3086                   S.Context.getCanonicalType(S.Context.getTypeDeclType(Class)));
3087   DeclContext::lookup_iterator Con, ConEnd;
3088   OverloadCandidateSet CandidateSet(Loc);
3089   for (llvm::tie(Con, ConEnd) = Class->lookup(ConstructorName);
3090        Con != ConEnd; ++Con) {
3091     // Find the constructor (which may be a template).
3092     CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(*Con);
3093     if (!Constructor || Constructor->isInvalidDecl() ||
3094         !Constructor->isCopyConstructor())
3095       continue;
3096
3097     S.AddOverloadCandidate(Constructor, Constructor->getAccess(),
3098                            &CurInitExpr, 1, CandidateSet);
3099   }
3100
3101   OverloadCandidateSet::iterator Best;
3102   switch (S.BestViableFunction(CandidateSet, Loc, Best)) {
3103   case OR_Success:
3104     break;
3105
3106   case OR_No_Viable_Function:
3107     S.Diag(Loc, diag::err_temp_copy_no_viable)
3108       << (int)Entity.getKind() << CurInitExpr->getType()
3109       << CurInitExpr->getSourceRange();
3110     S.PrintOverloadCandidates(CandidateSet, Sema::OCD_AllCandidates,
3111                               &CurInitExpr, 1);
3112     return S.ExprError();
3113
3114   case OR_Ambiguous:
3115     S.Diag(Loc, diag::err_temp_copy_ambiguous)
3116       << (int)Entity.getKind() << CurInitExpr->getType()
3117       << CurInitExpr->getSourceRange();
3118     S.PrintOverloadCandidates(CandidateSet, Sema::OCD_ViableCandidates,
3119                               &CurInitExpr, 1);
3120     return S.ExprError();
3121
3122   case OR_Deleted:
3123     S.Diag(Loc, diag::err_temp_copy_deleted)
3124       << (int)Entity.getKind() << CurInitExpr->getType()
3125       << CurInitExpr->getSourceRange();
3126     S.Diag(Best->Function->getLocation(), diag::note_unavailable_here)
3127       << Best->Function->isDeleted();
3128     return S.ExprError();
3129   }
3130
3131   CurInit.release();
3132   return S.BuildCXXConstructExpr(Loc, CurInitExpr->getType(),
3133                                  cast<CXXConstructorDecl>(Best->Function),
3134                                  /*Elidable=*/true,
3135                                  Sema::MultiExprArg(S,
3136                                                     (void**)&CurInitExpr, 1));
3137 }
3138
3139 Action::OwningExprResult
3140 InitializationSequence::Perform(Sema &S,
3141                                 const InitializedEntity &Entity,
3142                                 const InitializationKind &Kind,
3143                                 Action::MultiExprArg Args,
3144                                 QualType *ResultType) {
3145   if (SequenceKind == FailedSequence) {
3146     unsigned NumArgs = Args.size();
3147     Diagnose(S, Entity, Kind, (Expr **)Args.release(), NumArgs);
3148     return S.ExprError();
3149   }
3150
3151   if (SequenceKind == DependentSequence) {
3152     // If the declaration is a non-dependent, incomplete array type
3153     // that has an initializer, then its type will be completed once
3154     // the initializer is instantiated.
3155     if (ResultType && !Entity.getType()->isDependentType() &&
3156         Args.size() == 1) {
3157       QualType DeclType = Entity.getType();
3158       if (const IncompleteArrayType *ArrayT
3159                            = S.Context.getAsIncompleteArrayType(DeclType)) {
3160         // FIXME: We don't currently have the ability to accurately
3161         // compute the length of an initializer list without
3162         // performing full type-checking of the initializer list
3163         // (since we have to determine where braces are implicitly
3164         // introduced and such).  So, we fall back to making the array
3165         // type a dependently-sized array type with no specified
3166         // bound.
3167         if (isa<InitListExpr>((Expr *)Args.get()[0])) {
3168           SourceRange Brackets;
3169
3170           // Scavange the location of the brackets from the entity, if we can.
3171           if (DeclaratorDecl *DD = Entity.getDecl()) {
3172             if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
3173               TypeLoc TL = TInfo->getTypeLoc();
3174               if (IncompleteArrayTypeLoc *ArrayLoc
3175                                       = dyn_cast<IncompleteArrayTypeLoc>(&TL))
3176               Brackets = ArrayLoc->getBracketsRange();
3177             }
3178           }
3179
3180           *ResultType
3181             = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
3182                                                    /*NumElts=*/0,
3183                                                    ArrayT->getSizeModifier(),
3184                                        ArrayT->getIndexTypeCVRQualifiers(),
3185                                                    Brackets);
3186         }
3187
3188       }
3189     }
3190
3191     if (Kind.getKind() == InitializationKind::IK_Copy || Kind.isExplicitCast())
3192       return Sema::OwningExprResult(S, Args.release()[0]);
3193
3194     if (Args.size() == 0)
3195       return S.Owned((Expr *)0);
3196
3197     unsigned NumArgs = Args.size();
3198     return S.Owned(new (S.Context) ParenListExpr(S.Context,
3199                                                  SourceLocation(),
3200                                                  (Expr **)Args.release(),
3201                                                  NumArgs,
3202                                                  SourceLocation()));
3203   }
3204
3205   if (SequenceKind == NoInitialization)
3206     return S.Owned((Expr *)0);
3207
3208   QualType DestType = Entity.getType().getNonReferenceType();
3209   // FIXME: Ugly hack around the fact that Entity.getType() is not
3210   // the same as Entity.getDecl()->getType() in cases involving type merging,
3211   //  and we want latter when it makes sense.
3212   if (ResultType)
3213     *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
3214                                      Entity.getType();
3215
3216   Sema::OwningExprResult CurInit = S.Owned((Expr *)0);
3217
3218   assert(!Steps.empty() && "Cannot have an empty initialization sequence");
3219
3220   // For initialization steps that start with a single initializer,
3221   // grab the only argument out the Args and place it into the "current"
3222   // initializer.
3223   switch (Steps.front().Kind) {
3224   case SK_ResolveAddressOfOverloadedFunction:
3225   case SK_CastDerivedToBaseRValue:
3226   case SK_CastDerivedToBaseLValue:
3227   case SK_BindReference:
3228   case SK_BindReferenceToTemporary:
3229   case SK_UserConversion:
3230   case SK_QualificationConversionLValue:
3231   case SK_QualificationConversionRValue:
3232   case SK_ConversionSequence:
3233   case SK_ListInitialization:
3234   case SK_CAssignment:
3235   case SK_StringInit:
3236     assert(Args.size() == 1);
3237     CurInit = Sema::OwningExprResult(S, ((Expr **)(Args.get()))[0]->Retain());
3238     if (CurInit.isInvalid())
3239       return S.ExprError();
3240     break;
3241
3242   case SK_ConstructorInitialization:
3243   case SK_ZeroInitialization:
3244     break;
3245   }
3246
3247   // Walk through the computed steps for the initialization sequence,
3248   // performing the specified conversions along the way.
3249   bool ConstructorInitRequiresZeroInit = false;
3250   for (step_iterator Step = step_begin(), StepEnd = step_end();
3251        Step != StepEnd; ++Step) {
3252     if (CurInit.isInvalid())
3253       return S.ExprError();
3254
3255     Expr *CurInitExpr = (Expr *)CurInit.get();
3256     QualType SourceType = CurInitExpr? CurInitExpr->getType() : QualType();
3257
3258     switch (Step->Kind) {
3259     case SK_ResolveAddressOfOverloadedFunction:
3260       // Overload resolution determined which function invoke; update the
3261       // initializer to reflect that choice.
3262       // Access control was done in overload resolution.
3263       CurInit = S.FixOverloadedFunctionReference(move(CurInit),
3264                               cast<FunctionDecl>(Step->Function.getDecl()));
3265       break;
3266
3267     case SK_CastDerivedToBaseRValue:
3268     case SK_CastDerivedToBaseLValue: {
3269       // We have a derived-to-base cast that produces either an rvalue or an
3270       // lvalue. Perform that cast.
3271
3272       // Casts to inaccessible base classes are allowed with C-style casts.
3273       bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
3274       if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
3275                                          CurInitExpr->getLocStart(),
3276                                          CurInitExpr->getSourceRange(),
3277                                          IgnoreBaseAccess))
3278         return S.ExprError();
3279
3280       CurInit = S.Owned(new (S.Context) ImplicitCastExpr(Step->Type,
3281                                                     CastExpr::CK_DerivedToBase,
3282                                                       (Expr*)CurInit.release(),
3283                                      Step->Kind == SK_CastDerivedToBaseLValue));
3284       break;
3285     }
3286
3287     case SK_BindReference:
3288       if (FieldDecl *BitField = CurInitExpr->getBitField()) {
3289         // References cannot bind to bit fields (C++ [dcl.init.ref]p5).
3290         S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
3291           << Entity.getType().isVolatileQualified()
3292           << BitField->getDeclName()
3293           << CurInitExpr->getSourceRange();
3294         S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
3295         return S.ExprError();
3296       }
3297
3298       if (CurInitExpr->refersToVectorElement()) {
3299         // References cannot bind to vector elements.
3300         S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
3301           << Entity.getType().isVolatileQualified()
3302           << CurInitExpr->getSourceRange();
3303         return S.ExprError();
3304       }
3305
3306       // Reference binding does not have any corresponding ASTs.
3307
3308       // Check exception specifications
3309       if (S.CheckExceptionSpecCompatibility(CurInitExpr, DestType))
3310         return S.ExprError();
3311
3312       break;
3313
3314     case SK_BindReferenceToTemporary:
3315       // Reference binding does not have any corresponding ASTs.
3316
3317       // Check exception specifications
3318       if (S.CheckExceptionSpecCompatibility(CurInitExpr, DestType))
3319         return S.ExprError();
3320
3321       break;
3322
3323     case SK_UserConversion: {
3324       // We have a user-defined conversion that invokes either a constructor
3325       // or a conversion function.
3326       CastExpr::CastKind CastKind = CastExpr::CK_Unknown;
3327       bool IsCopy = false;
3328       FunctionDecl *Fn = cast<FunctionDecl>(Step->Function.getDecl());
3329       AccessSpecifier FnAccess = Step->Function.getAccess();
3330       if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
3331         // Build a call to the selected constructor.
3332         ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(S);
3333         SourceLocation Loc = CurInitExpr->getLocStart();
3334         CurInit.release(); // Ownership transferred into MultiExprArg, below.
3335
3336         // Determine the arguments required to actually perform the constructor
3337         // call.
3338         if (S.CompleteConstructorCall(Constructor,
3339                                       Sema::MultiExprArg(S,
3340                                                          (void **)&CurInitExpr,
3341                                                          1),
3342                                       Loc, ConstructorArgs))
3343           return S.ExprError();
3344
3345         // Build the an expression that constructs a temporary.
3346         CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor,
3347                                           move_arg(ConstructorArgs));
3348         if (CurInit.isInvalid())
3349           return S.ExprError();
3350
3351         S.CheckConstructorAccess(Kind.getLocation(), Constructor, FnAccess);
3352
3353         CastKind = CastExpr::CK_ConstructorConversion;
3354         QualType Class = S.Context.getTypeDeclType(Constructor->getParent());
3355         if (S.Context.hasSameUnqualifiedType(SourceType, Class) ||
3356             S.IsDerivedFrom(SourceType, Class))
3357           IsCopy = true;
3358       } else {
3359         // Build a call to the conversion function.
3360         CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
3361
3362         S.CheckMemberOperatorAccess(Kind.getLocation(), CurInitExpr,
3363                                     Conversion, FnAccess);
3364
3365         // FIXME: Should we move this initialization into a separate
3366         // derived-to-base conversion? I believe the answer is "no", because
3367         // we don't want to turn off access control here for c-style casts.
3368         if (S.PerformObjectArgumentInitialization(CurInitExpr, Conversion))
3369           return S.ExprError();
3370
3371         // Do a little dance to make sure that CurInit has the proper
3372         // pointer.
3373         CurInit.release();
3374
3375         // Build the actual call to the conversion function.
3376         CurInit = S.Owned(S.BuildCXXMemberCallExpr(CurInitExpr, Conversion));
3377         if (CurInit.isInvalid() || !CurInit.get())
3378           return S.ExprError();
3379
3380         CastKind = CastExpr::CK_UserDefinedConversion;
3381       }
3382
3383       if (shouldBindAsTemporary(Entity, IsCopy))
3384         CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
3385
3386       CurInitExpr = CurInit.takeAs<Expr>();
3387       CurInit = S.Owned(new (S.Context) ImplicitCastExpr(CurInitExpr->getType(),
3388                                                          CastKind,
3389                                                          CurInitExpr,
3390                                                          false));
3391
3392       if (!IsCopy)
3393         CurInit = CopyIfRequiredForEntity(S, Entity, Kind, move(CurInit));
3394       break;
3395     }
3396
3397     case SK_QualificationConversionLValue:
3398     case SK_QualificationConversionRValue:
3399       // Perform a qualification conversion; these can never go wrong.
3400       S.ImpCastExprToType(CurInitExpr, Step->Type,
3401                           CastExpr::CK_NoOp,
3402                           Step->Kind == SK_QualificationConversionLValue);
3403       CurInit.release();
3404       CurInit = S.Owned(CurInitExpr);
3405       break;
3406
3407     case SK_ConversionSequence:
3408         if (S.PerformImplicitConversion(CurInitExpr, Step->Type, Sema::AA_Converting,
3409                                       false, false, *Step->ICS))
3410         return S.ExprError();
3411
3412       CurInit.release();
3413       CurInit = S.Owned(CurInitExpr);
3414       break;
3415
3416     case SK_ListInitialization: {
3417       InitListExpr *InitList = cast<InitListExpr>(CurInitExpr);
3418       QualType Ty = Step->Type;
3419       if (S.CheckInitList(Entity, InitList, ResultType? *ResultType : Ty))
3420         return S.ExprError();
3421
3422       CurInit.release();
3423       CurInit = S.Owned(InitList);
3424       break;
3425     }
3426
3427     case SK_ConstructorInitialization: {
3428       CXXConstructorDecl *Constructor
3429         = cast<CXXConstructorDecl>(Step->Function.getDecl());
3430
3431       // Build a call to the selected constructor.
3432       ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(S);
3433       SourceLocation Loc = Kind.getLocation();
3434
3435       // Determine the arguments required to actually perform the constructor
3436       // call.
3437       if (S.CompleteConstructorCall(Constructor, move(Args),
3438                                     Loc, ConstructorArgs))
3439         return S.ExprError();
3440
3441       // Build the an expression that constructs a temporary.
3442       CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
3443                                         Constructor,
3444                                         move_arg(ConstructorArgs),
3445                                         ConstructorInitRequiresZeroInit,
3446                                Entity.getKind() == InitializedEntity::EK_Base);
3447       if (CurInit.isInvalid())
3448         return S.ExprError();
3449
3450       // Only check access if all of that succeeded.
3451       S.CheckConstructorAccess(Loc, Constructor, Step->Function.getAccess());
3452
3453       bool Elidable
3454         = cast<CXXConstructExpr>((Expr *)CurInit.get())->isElidable();
3455       if (shouldBindAsTemporary(Entity, Elidable))
3456         CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
3457
3458       if (!Elidable)
3459         CurInit = CopyIfRequiredForEntity(S, Entity, Kind, move(CurInit));
3460       break;
3461     }
3462
3463     case SK_ZeroInitialization: {
3464       step_iterator NextStep = Step;
3465       ++NextStep;
3466       if (NextStep != StepEnd &&
3467           NextStep->Kind == SK_ConstructorInitialization) {
3468         // The need for zero-initialization is recorded directly into
3469         // the call to the object's constructor within the next step.
3470         ConstructorInitRequiresZeroInit = true;
3471       } else if (Kind.getKind() == InitializationKind::IK_Value &&
3472                  S.getLangOptions().CPlusPlus &&
3473                  !Kind.isImplicitValueInit()) {
3474         CurInit = S.Owned(new (S.Context) CXXZeroInitValueExpr(Step->Type,
3475                                                    Kind.getRange().getBegin(),
3476                                                     Kind.getRange().getEnd()));
3477       } else {
3478         CurInit = S.Owned(new (S.Context) ImplicitValueInitExpr(Step->Type));
3479       }
3480       break;
3481     }
3482
3483     case SK_CAssignment: {
3484       QualType SourceType = CurInitExpr->getType();
3485       Sema::AssignConvertType ConvTy =
3486         S.CheckSingleAssignmentConstraints(Step->Type, CurInitExpr);
3487
3488       // If this is a call, allow conversion to a transparent union.
3489       if (ConvTy != Sema::Compatible &&
3490           Entity.getKind() == InitializedEntity::EK_Parameter &&
3491           S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExpr)
3492             == Sema::Compatible)
3493         ConvTy = Sema::Compatible;
3494
3495       if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
3496                                      Step->Type, SourceType,
3497                                      CurInitExpr, getAssignmentAction(Entity)))
3498         return S.ExprError();
3499
3500       CurInit.release();
3501       CurInit = S.Owned(CurInitExpr);
3502       break;
3503     }
3504
3505     case SK_StringInit: {
3506       QualType Ty = Step->Type;
3507       CheckStringInit(CurInitExpr, ResultType ? *ResultType : Ty, S);
3508       break;
3509     }
3510     }
3511   }
3512
3513   return move(CurInit);
3514 }
3515
3516 //===----------------------------------------------------------------------===//
3517 // Diagnose initialization failures
3518 //===----------------------------------------------------------------------===//
3519 bool InitializationSequence::Diagnose(Sema &S,
3520                                       const InitializedEntity &Entity,
3521                                       const InitializationKind &Kind,
3522                                       Expr **Args, unsigned NumArgs) {
3523   if (SequenceKind != FailedSequence)
3524     return false;
3525
3526   QualType DestType = Entity.getType();
3527   switch (Failure) {
3528   case FK_TooManyInitsForReference:
3529     // FIXME: Customize for the initialized entity?
3530     if (NumArgs == 0)
3531       S.Diag(Kind.getLocation(), diag::err_reference_without_init)
3532         << DestType.getNonReferenceType();
3533     else  // FIXME: diagnostic below could be better!
3534       S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
3535         << SourceRange(Args[0]->getLocStart(), Args[NumArgs - 1]->getLocEnd());
3536     break;
3537
3538   case FK_ArrayNeedsInitList:
3539   case FK_ArrayNeedsInitListOrStringLiteral:
3540     S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list)
3541       << (Failure == FK_ArrayNeedsInitListOrStringLiteral);
3542     break;
3543
3544   case FK_AddressOfOverloadFailed:
3545     S.ResolveAddressOfOverloadedFunction(Args[0],
3546                                          DestType.getNonReferenceType(),
3547                                          true);
3548     break;
3549
3550   case FK_ReferenceInitOverloadFailed:
3551   case FK_UserConversionOverloadFailed:
3552     switch (FailedOverloadResult) {
3553     case OR_Ambiguous:
3554       if (Failure == FK_UserConversionOverloadFailed)
3555         S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
3556           << Args[0]->getType() << DestType
3557           << Args[0]->getSourceRange();
3558       else
3559         S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
3560           << DestType << Args[0]->getType()
3561           << Args[0]->getSourceRange();
3562
3563       S.PrintOverloadCandidates(FailedCandidateSet, Sema::OCD_ViableCandidates,
3564                                 Args, NumArgs);
3565       break;
3566
3567     case OR_No_Viable_Function:
3568       S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
3569         << Args[0]->getType() << DestType.getNonReferenceType()
3570         << Args[0]->getSourceRange();
3571       S.PrintOverloadCandidates(FailedCandidateSet, Sema::OCD_AllCandidates,
3572                                 Args, NumArgs);
3573       break;
3574
3575     case OR_Deleted: {
3576       S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
3577         << Args[0]->getType() << DestType.getNonReferenceType()
3578         << Args[0]->getSourceRange();
3579       OverloadCandidateSet::iterator Best;
3580       OverloadingResult Ovl = S.BestViableFunction(FailedCandidateSet,
3581                                                    Kind.getLocation(),
3582                                                    Best);
3583       if (Ovl == OR_Deleted) {
3584         S.Diag(Best->Function->getLocation(), diag::note_unavailable_here)
3585           << Best->Function->isDeleted();
3586       } else {
3587         llvm_unreachable("Inconsistent overload resolution?");
3588       }
3589       break;
3590     }
3591
3592     case OR_Success:
3593       llvm_unreachable("Conversion did not fail!");
3594       break;
3595     }
3596     break;
3597
3598   case FK_NonConstLValueReferenceBindingToTemporary:
3599   case FK_NonConstLValueReferenceBindingToUnrelated:
3600     S.Diag(Kind.getLocation(),
3601            Failure == FK_NonConstLValueReferenceBindingToTemporary
3602              ? diag::err_lvalue_reference_bind_to_temporary
3603              : diag::err_lvalue_reference_bind_to_unrelated)
3604       << DestType.getNonReferenceType().isVolatileQualified()
3605       << DestType.getNonReferenceType()
3606       << Args[0]->getType()
3607       << Args[0]->getSourceRange();
3608     break;
3609
3610   case FK_RValueReferenceBindingToLValue:
3611     S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
3612       << Args[0]->getSourceRange();
3613     break;
3614
3615   case FK_ReferenceInitDropsQualifiers:
3616     S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
3617       << DestType.getNonReferenceType()
3618       << Args[0]->getType()
3619       << Args[0]->getSourceRange();
3620     break;
3621
3622   case FK_ReferenceInitFailed:
3623     S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
3624       << DestType.getNonReferenceType()
3625       << (Args[0]->isLvalue(S.Context) == Expr::LV_Valid)
3626       << Args[0]->getType()
3627       << Args[0]->getSourceRange();
3628     break;
3629
3630   case FK_ConversionFailed:
3631     S.Diag(Kind.getLocation(), diag::err_init_conversion_failed)
3632       << (int)Entity.getKind()
3633       << DestType
3634       << (Args[0]->isLvalue(S.Context) == Expr::LV_Valid)
3635       << Args[0]->getType()
3636       << Args[0]->getSourceRange();
3637     break;
3638
3639   case FK_TooManyInitsForScalar: {
3640     SourceRange R;
3641
3642     if (InitListExpr *InitList = dyn_cast<InitListExpr>(Args[0]))
3643       R = SourceRange(InitList->getInit(1)->getLocStart(),
3644                       InitList->getLocEnd());
3645     else
3646       R = SourceRange(Args[0]->getLocStart(), Args[NumArgs - 1]->getLocEnd());
3647
3648     S.Diag(Kind.getLocation(), diag::err_excess_initializers)
3649       << /*scalar=*/2 << R;
3650     break;
3651   }
3652
3653   case FK_ReferenceBindingToInitList:
3654     S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
3655       << DestType.getNonReferenceType() << Args[0]->getSourceRange();
3656     break;
3657
3658   case FK_InitListBadDestinationType:
3659     S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
3660       << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
3661     break;
3662
3663   case FK_ConstructorOverloadFailed: {
3664     SourceRange ArgsRange;
3665     if (NumArgs)
3666       ArgsRange = SourceRange(Args[0]->getLocStart(),
3667                               Args[NumArgs - 1]->getLocEnd());
3668
3669     // FIXME: Using "DestType" for the entity we're printing is probably
3670     // bad.
3671     switch (FailedOverloadResult) {
3672       case OR_Ambiguous:
3673         S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
3674           << DestType << ArgsRange;
3675         S.PrintOverloadCandidates(FailedCandidateSet,
3676                                   Sema::OCD_ViableCandidates, Args, NumArgs);
3677         break;
3678
3679       case OR_No_Viable_Function:
3680         if (Kind.getKind() == InitializationKind::IK_Default &&
3681             (Entity.getKind() == InitializedEntity::EK_Base ||
3682              Entity.getKind() == InitializedEntity::EK_Member) &&
3683             isa<CXXConstructorDecl>(S.CurContext)) {
3684           // This is implicit default initialization of a member or
3685           // base within a constructor. If no viable function was
3686           // found, notify the user that she needs to explicitly
3687           // initialize this base/member.
3688           CXXConstructorDecl *Constructor
3689             = cast<CXXConstructorDecl>(S.CurContext);
3690           if (Entity.getKind() == InitializedEntity::EK_Base) {
3691             S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
3692               << Constructor->isImplicit()
3693               << S.Context.getTypeDeclType(Constructor->getParent())
3694               << /*base=*/0
3695               << Entity.getType();
3696
3697             RecordDecl *BaseDecl
3698               = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
3699                                                                   ->getDecl();
3700             S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
3701               << S.Context.getTagDeclType(BaseDecl);
3702           } else {
3703             S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
3704               << Constructor->isImplicit()
3705               << S.Context.getTypeDeclType(Constructor->getParent())
3706               << /*member=*/1
3707               << Entity.getName();
3708             S.Diag(Entity.getDecl()->getLocation(), diag::note_field_decl);
3709
3710             if (const RecordType *Record
3711                                  = Entity.getType()->getAs<RecordType>())
3712               S.Diag(Record->getDecl()->getLocation(),
3713                      diag::note_previous_decl)
3714                 << S.Context.getTagDeclType(Record->getDecl());
3715           }
3716           break;
3717         }
3718
3719         S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
3720           << DestType << ArgsRange;
3721         S.PrintOverloadCandidates(FailedCandidateSet, Sema::OCD_AllCandidates,
3722                                   Args, NumArgs);
3723         break;
3724
3725       case OR_Deleted: {
3726         S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
3727           << true << DestType << ArgsRange;
3728         OverloadCandidateSet::iterator Best;
3729         OverloadingResult Ovl = S.BestViableFunction(FailedCandidateSet,
3730                                                      Kind.getLocation(),
3731                                                      Best);
3732         if (Ovl == OR_Deleted) {
3733           S.Diag(Best->Function->getLocation(), diag::note_unavailable_here)
3734             << Best->Function->isDeleted();
3735         } else {
3736           llvm_unreachable("Inconsistent overload resolution?");
3737         }
3738         break;
3739       }
3740
3741       case OR_Success:
3742         llvm_unreachable("Conversion did not fail!");
3743         break;
3744     }
3745     break;
3746   }
3747
3748   case FK_DefaultInitOfConst:
3749     if (Entity.getKind() == InitializedEntity::EK_Member &&
3750         isa<CXXConstructorDecl>(S.CurContext)) {
3751       // This is implicit default-initialization of a const member in
3752       // a constructor. Complain that it needs to be explicitly
3753       // initialized.
3754       CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
3755       S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
3756         << Constructor->isImplicit()
3757         << S.Context.getTypeDeclType(Constructor->getParent())
3758         << /*const=*/1
3759         << Entity.getName();
3760       S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
3761         << Entity.getName();
3762     } else {
3763       S.Diag(Kind.getLocation(), diag::err_default_init_const)
3764         << DestType << (bool)DestType->getAs<RecordType>();
3765     }
3766     break;
3767   }
3768
3769   return true;
3770 }
3771
3772 void InitializationSequence::dump(llvm::raw_ostream &OS) const {
3773   switch (SequenceKind) {
3774   case FailedSequence: {
3775     OS << "Failed sequence: ";
3776     switch (Failure) {
3777     case FK_TooManyInitsForReference:
3778       OS << "too many initializers for reference";
3779       break;
3780
3781     case FK_ArrayNeedsInitList:
3782       OS << "array requires initializer list";
3783       break;
3784
3785     case FK_ArrayNeedsInitListOrStringLiteral:
3786       OS << "array requires initializer list or string literal";
3787       break;
3788
3789     case FK_AddressOfOverloadFailed:
3790       OS << "address of overloaded function failed";
3791       break;
3792
3793     case FK_ReferenceInitOverloadFailed:
3794       OS << "overload resolution for reference initialization failed";
3795       break;
3796
3797     case FK_NonConstLValueReferenceBindingToTemporary:
3798       OS << "non-const lvalue reference bound to temporary";
3799       break;
3800
3801     case FK_NonConstLValueReferenceBindingToUnrelated:
3802       OS << "non-const lvalue reference bound to unrelated type";
3803       break;
3804
3805     case FK_RValueReferenceBindingToLValue:
3806       OS << "rvalue reference bound to an lvalue";
3807       break;
3808
3809     case FK_ReferenceInitDropsQualifiers:
3810       OS << "reference initialization drops qualifiers";
3811       break;
3812
3813     case FK_ReferenceInitFailed:
3814       OS << "reference initialization failed";
3815       break;
3816
3817     case FK_ConversionFailed:
3818       OS << "conversion failed";
3819       break;
3820
3821     case FK_TooManyInitsForScalar:
3822       OS << "too many initializers for scalar";
3823       break;
3824
3825     case FK_ReferenceBindingToInitList:
3826       OS << "referencing binding to initializer list";
3827       break;
3828
3829     case FK_InitListBadDestinationType:
3830       OS << "initializer list for non-aggregate, non-scalar type";
3831       break;
3832
3833     case FK_UserConversionOverloadFailed:
3834       OS << "overloading failed for user-defined conversion";
3835       break;
3836
3837     case FK_ConstructorOverloadFailed:
3838       OS << "constructor overloading failed";
3839       break;
3840
3841     case FK_DefaultInitOfConst:
3842       OS << "default initialization of a const variable";
3843       break;
3844     }
3845     OS << '\n';
3846     return;
3847   }
3848
3849   case DependentSequence:
3850     OS << "Dependent sequence: ";
3851     return;
3852
3853   case UserDefinedConversion:
3854     OS << "User-defined conversion sequence: ";
3855     break;
3856
3857   case ConstructorInitialization:
3858     OS << "Constructor initialization sequence: ";
3859     break;
3860
3861   case ReferenceBinding:
3862     OS << "Reference binding: ";
3863     break;
3864
3865   case ListInitialization:
3866     OS << "List initialization: ";
3867     break;
3868
3869   case ZeroInitialization:
3870     OS << "Zero initialization\n";
3871     return;
3872
3873   case NoInitialization:
3874     OS << "No initialization\n";
3875     return;
3876
3877   case StandardConversion:
3878     OS << "Standard conversion: ";
3879     break;
3880
3881   case CAssignment:
3882     OS << "C assignment: ";
3883     break;
3884
3885   case StringInit:
3886     OS << "String initialization: ";
3887     break;
3888   }
3889
3890   for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
3891     if (S != step_begin()) {
3892       OS << " -> ";
3893     }
3894
3895     switch (S->Kind) {
3896     case SK_ResolveAddressOfOverloadedFunction:
3897       OS << "resolve address of overloaded function";
3898       break;
3899
3900     case SK_CastDerivedToBaseRValue:
3901       OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")";
3902       break;
3903
3904     case SK_CastDerivedToBaseLValue:
3905       OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")";
3906       break;
3907
3908     case SK_BindReference:
3909       OS << "bind reference to lvalue";
3910       break;
3911
3912     case SK_BindReferenceToTemporary:
3913       OS << "bind reference to a temporary";
3914       break;
3915
3916     case SK_UserConversion:
3917       OS << "user-defined conversion via " << S->Function->getNameAsString();
3918       break;
3919
3920     case SK_QualificationConversionRValue:
3921       OS << "qualification conversion (rvalue)";
3922
3923     case SK_QualificationConversionLValue:
3924       OS << "qualification conversion (lvalue)";
3925       break;
3926
3927     case SK_ConversionSequence:
3928       OS << "implicit conversion sequence (";
3929       S->ICS->DebugPrint(); // FIXME: use OS
3930       OS << ")";
3931       break;
3932
3933     case SK_ListInitialization:
3934       OS << "list initialization";
3935       break;
3936
3937     case SK_ConstructorInitialization:
3938       OS << "constructor initialization";
3939       break;
3940
3941     case SK_ZeroInitialization:
3942       OS << "zero initialization";
3943       break;
3944
3945     case SK_CAssignment:
3946       OS << "C assignment";
3947       break;
3948
3949     case SK_StringInit:
3950       OS << "string initialization";
3951       break;
3952     }
3953   }
3954 }
3955
3956 void InitializationSequence::dump() const {
3957   dump(llvm::errs());
3958 }
3959
3960 //===----------------------------------------------------------------------===//
3961 // Initialization helper functions
3962 //===----------------------------------------------------------------------===//
3963 Sema::OwningExprResult
3964 Sema::PerformCopyInitialization(const InitializedEntity &Entity,
3965                                 SourceLocation EqualLoc,
3966                                 OwningExprResult Init) {
3967   if (Init.isInvalid())
3968     return ExprError();
3969
3970   Expr *InitE = (Expr *)Init.get();
3971   assert(InitE && "No initialization expression?");
3972
3973   if (EqualLoc.isInvalid())
3974     EqualLoc = InitE->getLocStart();
3975
3976   InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
3977                                                            EqualLoc);
3978   InitializationSequence Seq(*this, Entity, Kind, &InitE, 1);
3979   Init.release();
3980   return Seq.Perform(*this, Entity, Kind,
3981                      MultiExprArg(*this, (void**)&InitE, 1));
3982 }