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