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