1 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements semantic analysis for initializers.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/DeclObjC.h"
16 #include "clang/AST/ExprCXX.h"
17 #include "clang/AST/ExprObjC.h"
18 #include "clang/AST/TypeLoc.h"
19 #include "clang/Basic/TargetInfo.h"
20 #include "clang/Sema/Designator.h"
21 #include "clang/Sema/Initialization.h"
22 #include "clang/Sema/Lookup.h"
23 #include "clang/Sema/SemaInternal.h"
24 #include "llvm/ADT/APInt.h"
25 #include "llvm/ADT/SmallString.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/raw_ostream.h"
28 
29 using namespace clang;
30 
31 //===----------------------------------------------------------------------===//
32 // Sema Initialization Checking
33 //===----------------------------------------------------------------------===//
34 
35 /// \brief Check whether T is compatible with a wide character type (wchar_t,
36 /// char16_t or char32_t).
37 static bool IsWideCharCompatible(QualType T, ASTContext &Context) {
38   if (Context.typesAreCompatible(Context.getWideCharType(), T))
39     return true;
40   if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) {
41     return Context.typesAreCompatible(Context.Char16Ty, T) ||
42            Context.typesAreCompatible(Context.Char32Ty, T);
43   }
44   return false;
45 }
46 
47 enum StringInitFailureKind {
48   SIF_None,
49   SIF_NarrowStringIntoWideChar,
50   SIF_WideStringIntoChar,
51   SIF_IncompatWideStringIntoWideChar,
52   SIF_Other
53 };
54 
55 /// \brief Check whether the array of type AT can be initialized by the Init
56 /// expression by means of string initialization. Returns SIF_None if so,
57 /// otherwise returns a StringInitFailureKind that describes why the
58 /// initialization would not work.
59 static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT,
60                                           ASTContext &Context) {
61   if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
62     return SIF_Other;
63 
64   // See if this is a string literal or @encode.
65   Init = Init->IgnoreParens();
66 
67   // Handle @encode, which is a narrow string.
68   if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
69     return SIF_None;
70 
71   // Otherwise we can only handle string literals.
72   StringLiteral *SL = dyn_cast<StringLiteral>(Init);
73   if (!SL)
74     return SIF_Other;
75 
76   const QualType ElemTy =
77       Context.getCanonicalType(AT->getElementType()).getUnqualifiedType();
78 
79   switch (SL->getKind()) {
80   case StringLiteral::Ascii:
81   case StringLiteral::UTF8:
82     // char array can be initialized with a narrow string.
83     // Only allow char x[] = "foo";  not char x[] = L"foo";
84     if (ElemTy->isCharType())
85       return SIF_None;
86     if (IsWideCharCompatible(ElemTy, Context))
87       return SIF_NarrowStringIntoWideChar;
88     return SIF_Other;
89   // C99 6.7.8p15 (with correction from DR343), or C11 6.7.9p15:
90   // "An array with element type compatible with a qualified or unqualified
91   // version of wchar_t, char16_t, or char32_t may be initialized by a wide
92   // string literal with the corresponding encoding prefix (L, u, or U,
93   // respectively), optionally enclosed in braces.
94   case StringLiteral::UTF16:
95     if (Context.typesAreCompatible(Context.Char16Ty, ElemTy))
96       return SIF_None;
97     if (ElemTy->isCharType())
98       return SIF_WideStringIntoChar;
99     if (IsWideCharCompatible(ElemTy, Context))
100       return SIF_IncompatWideStringIntoWideChar;
101     return SIF_Other;
102   case StringLiteral::UTF32:
103     if (Context.typesAreCompatible(Context.Char32Ty, ElemTy))
104       return SIF_None;
105     if (ElemTy->isCharType())
106       return SIF_WideStringIntoChar;
107     if (IsWideCharCompatible(ElemTy, Context))
108       return SIF_IncompatWideStringIntoWideChar;
109     return SIF_Other;
110   case StringLiteral::Wide:
111     if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy))
112       return SIF_None;
113     if (ElemTy->isCharType())
114       return SIF_WideStringIntoChar;
115     if (IsWideCharCompatible(ElemTy, Context))
116       return SIF_IncompatWideStringIntoWideChar;
117     return SIF_Other;
118   }
119 
120   llvm_unreachable("missed a StringLiteral kind?");
121 }
122 
123 static StringInitFailureKind IsStringInit(Expr *init, QualType declType,
124                                           ASTContext &Context) {
125   const ArrayType *arrayType = Context.getAsArrayType(declType);
126   if (!arrayType)
127     return SIF_Other;
128   return IsStringInit(init, arrayType, Context);
129 }
130 
131 /// Update the type of a string literal, including any surrounding parentheses,
132 /// to match the type of the object which it is initializing.
133 static void updateStringLiteralType(Expr *E, QualType Ty) {
134   while (true) {
135     E->setType(Ty);
136     if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
137       break;
138     else if (ParenExpr *PE = dyn_cast<ParenExpr>(E))
139       E = PE->getSubExpr();
140     else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
141       E = UO->getSubExpr();
142     else if (GenericSelectionExpr *GSE = dyn_cast<GenericSelectionExpr>(E))
143       E = GSE->getResultExpr();
144     else
145       llvm_unreachable("unexpected expr in string literal init");
146   }
147 }
148 
149 static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,
150                             Sema &S) {
151   // Get the length of the string as parsed.
152   auto *ConstantArrayTy =
153       cast<ConstantArrayType>(Str->getType()->getAsArrayTypeUnsafe());
154   uint64_t StrLength = ConstantArrayTy->getSize().getZExtValue();
155 
156   if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
157     // C99 6.7.8p14. We have an array of character type with unknown size
158     // being initialized to a string literal.
159     llvm::APInt ConstVal(32, StrLength);
160     // Return a new array type (C99 6.7.8p22).
161     DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
162                                            ConstVal,
163                                            ArrayType::Normal, 0);
164     updateStringLiteralType(Str, DeclT);
165     return;
166   }
167 
168   const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
169 
170   // We have an array of character type with known size.  However,
171   // the size may be smaller or larger than the string we are initializing.
172   // FIXME: Avoid truncation for 64-bit length strings.
173   if (S.getLangOpts().CPlusPlus) {
174     if (StringLiteral *SL = dyn_cast<StringLiteral>(Str->IgnoreParens())) {
175       // For Pascal strings it's OK to strip off the terminating null character,
176       // so the example below is valid:
177       //
178       // unsigned char a[2] = "\pa";
179       if (SL->isPascal())
180         StrLength--;
181     }
182 
183     // [dcl.init.string]p2
184     if (StrLength > CAT->getSize().getZExtValue())
185       S.Diag(Str->getLocStart(),
186              diag::err_initializer_string_for_char_array_too_long)
187         << Str->getSourceRange();
188   } else {
189     // C99 6.7.8p14.
190     if (StrLength-1 > CAT->getSize().getZExtValue())
191       S.Diag(Str->getLocStart(),
192              diag::ext_initializer_string_for_char_array_too_long)
193         << Str->getSourceRange();
194   }
195 
196   // Set the type to the actual size that we are initializing.  If we have
197   // something like:
198   //   char x[1] = "foo";
199   // then this will set the string literal's type to char[1].
200   updateStringLiteralType(Str, DeclT);
201 }
202 
203 //===----------------------------------------------------------------------===//
204 // Semantic checking for initializer lists.
205 //===----------------------------------------------------------------------===//
206 
207 namespace {
208 
209 /// @brief Semantic checking for initializer lists.
210 ///
211 /// The InitListChecker class contains a set of routines that each
212 /// handle the initialization of a certain kind of entity, e.g.,
213 /// arrays, vectors, struct/union types, scalars, etc. The
214 /// InitListChecker itself performs a recursive walk of the subobject
215 /// structure of the type to be initialized, while stepping through
216 /// the initializer list one element at a time. The IList and Index
217 /// parameters to each of the Check* routines contain the active
218 /// (syntactic) initializer list and the index into that initializer
219 /// list that represents the current initializer. Each routine is
220 /// responsible for moving that Index forward as it consumes elements.
221 ///
222 /// Each Check* routine also has a StructuredList/StructuredIndex
223 /// arguments, which contains the current "structured" (semantic)
224 /// initializer list and the index into that initializer list where we
225 /// are copying initializers as we map them over to the semantic
226 /// list. Once we have completed our recursive walk of the subobject
227 /// structure, we will have constructed a full semantic initializer
228 /// list.
229 ///
230 /// C99 designators cause changes in the initializer list traversal,
231 /// because they make the initialization "jump" into a specific
232 /// subobject and then continue the initialization from that
233 /// point. CheckDesignatedInitializer() recursively steps into the
234 /// designated subobject and manages backing out the recursion to
235 /// initialize the subobjects after the one designated.
236 class InitListChecker {
237   Sema &SemaRef;
238   bool hadError;
239   bool VerifyOnly; // no diagnostics, no structure building
240   bool TreatUnavailableAsInvalid; // Used only in VerifyOnly mode.
241   llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic;
242   InitListExpr *FullyStructuredList;
243 
244   void CheckImplicitInitList(const InitializedEntity &Entity,
245                              InitListExpr *ParentIList, QualType T,
246                              unsigned &Index, InitListExpr *StructuredList,
247                              unsigned &StructuredIndex);
248   void CheckExplicitInitList(const InitializedEntity &Entity,
249                              InitListExpr *IList, QualType &T,
250                              InitListExpr *StructuredList,
251                              bool TopLevelObject = false);
252   void CheckListElementTypes(const InitializedEntity &Entity,
253                              InitListExpr *IList, QualType &DeclType,
254                              bool SubobjectIsDesignatorContext,
255                              unsigned &Index,
256                              InitListExpr *StructuredList,
257                              unsigned &StructuredIndex,
258                              bool TopLevelObject = false);
259   void CheckSubElementType(const InitializedEntity &Entity,
260                            InitListExpr *IList, QualType ElemType,
261                            unsigned &Index,
262                            InitListExpr *StructuredList,
263                            unsigned &StructuredIndex);
264   void CheckComplexType(const InitializedEntity &Entity,
265                         InitListExpr *IList, QualType DeclType,
266                         unsigned &Index,
267                         InitListExpr *StructuredList,
268                         unsigned &StructuredIndex);
269   void CheckScalarType(const InitializedEntity &Entity,
270                        InitListExpr *IList, QualType DeclType,
271                        unsigned &Index,
272                        InitListExpr *StructuredList,
273                        unsigned &StructuredIndex);
274   void CheckReferenceType(const InitializedEntity &Entity,
275                           InitListExpr *IList, QualType DeclType,
276                           unsigned &Index,
277                           InitListExpr *StructuredList,
278                           unsigned &StructuredIndex);
279   void CheckVectorType(const InitializedEntity &Entity,
280                        InitListExpr *IList, QualType DeclType, unsigned &Index,
281                        InitListExpr *StructuredList,
282                        unsigned &StructuredIndex);
283   void CheckStructUnionTypes(const InitializedEntity &Entity,
284                              InitListExpr *IList, QualType DeclType,
285                              CXXRecordDecl::base_class_range Bases,
286                              RecordDecl::field_iterator Field,
287                              bool SubobjectIsDesignatorContext, unsigned &Index,
288                              InitListExpr *StructuredList,
289                              unsigned &StructuredIndex,
290                              bool TopLevelObject = false);
291   void CheckArrayType(const InitializedEntity &Entity,
292                       InitListExpr *IList, QualType &DeclType,
293                       llvm::APSInt elementIndex,
294                       bool SubobjectIsDesignatorContext, unsigned &Index,
295                       InitListExpr *StructuredList,
296                       unsigned &StructuredIndex);
297   bool CheckDesignatedInitializer(const InitializedEntity &Entity,
298                                   InitListExpr *IList, DesignatedInitExpr *DIE,
299                                   unsigned DesigIdx,
300                                   QualType &CurrentObjectType,
301                                   RecordDecl::field_iterator *NextField,
302                                   llvm::APSInt *NextElementIndex,
303                                   unsigned &Index,
304                                   InitListExpr *StructuredList,
305                                   unsigned &StructuredIndex,
306                                   bool FinishSubobjectInit,
307                                   bool TopLevelObject);
308   InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
309                                            QualType CurrentObjectType,
310                                            InitListExpr *StructuredList,
311                                            unsigned StructuredIndex,
312                                            SourceRange InitRange,
313                                            bool IsFullyOverwritten = false);
314   void UpdateStructuredListElement(InitListExpr *StructuredList,
315                                    unsigned &StructuredIndex,
316                                    Expr *expr);
317   int numArrayElements(QualType DeclType);
318   int numStructUnionElements(QualType DeclType);
319 
320   static ExprResult PerformEmptyInit(Sema &SemaRef,
321                                      SourceLocation Loc,
322                                      const InitializedEntity &Entity,
323                                      bool VerifyOnly,
324                                      bool TreatUnavailableAsInvalid);
325 
326   // Explanation on the "FillWithNoInit" mode:
327   //
328   // Assume we have the following definitions (Case#1):
329   // struct P { char x[6][6]; } xp = { .x[1] = "bar" };
330   // struct PP { struct P lp; } l = { .lp = xp, .lp.x[1][2] = 'f' };
331   //
332   // l.lp.x[1][0..1] should not be filled with implicit initializers because the
333   // "base" initializer "xp" will provide values for them; l.lp.x[1] will be "baf".
334   //
335   // But if we have (Case#2):
336   // struct PP l = { .lp = xp, .lp.x[1] = { [2] = 'f' } };
337   //
338   // l.lp.x[1][0..1] are implicitly initialized and do not use values from the
339   // "base" initializer; l.lp.x[1] will be "\0\0f\0\0\0".
340   //
341   // To distinguish Case#1 from Case#2, and also to avoid leaving many "holes"
342   // in the InitListExpr, the "holes" in Case#1 are filled not with empty
343   // initializers but with special "NoInitExpr" place holders, which tells the
344   // CodeGen not to generate any initializers for these parts.
345   void FillInEmptyInitForBase(unsigned Init, const CXXBaseSpecifier &Base,
346                               const InitializedEntity &ParentEntity,
347                               InitListExpr *ILE, bool &RequiresSecondPass,
348                               bool FillWithNoInit);
349   void FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
350                                const InitializedEntity &ParentEntity,
351                                InitListExpr *ILE, bool &RequiresSecondPass,
352                                bool FillWithNoInit = false);
353   void FillInEmptyInitializations(const InitializedEntity &Entity,
354                                   InitListExpr *ILE, bool &RequiresSecondPass,
355                                   bool FillWithNoInit = false);
356   bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
357                               Expr *InitExpr, FieldDecl *Field,
358                               bool TopLevelObject);
359   void CheckEmptyInitializable(const InitializedEntity &Entity,
360                                SourceLocation Loc);
361 
362 public:
363   InitListChecker(Sema &S, const InitializedEntity &Entity,
364                   InitListExpr *IL, QualType &T, bool VerifyOnly,
365                   bool TreatUnavailableAsInvalid);
366   bool HadError() { return hadError; }
367 
368   // @brief Retrieves the fully-structured initializer list used for
369   // semantic analysis and code generation.
370   InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
371 };
372 
373 } // end anonymous namespace
374 
375 ExprResult InitListChecker::PerformEmptyInit(Sema &SemaRef,
376                                              SourceLocation Loc,
377                                              const InitializedEntity &Entity,
378                                              bool VerifyOnly,
379                                              bool TreatUnavailableAsInvalid) {
380   InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
381                                                             true);
382   MultiExprArg SubInit;
383   Expr *InitExpr;
384   InitListExpr DummyInitList(SemaRef.Context, Loc, None, Loc);
385 
386   // C++ [dcl.init.aggr]p7:
387   //   If there are fewer initializer-clauses in the list than there are
388   //   members in the aggregate, then each member not explicitly initialized
389   //   ...
390   bool EmptyInitList = SemaRef.getLangOpts().CPlusPlus11 &&
391       Entity.getType()->getBaseElementTypeUnsafe()->isRecordType();
392   if (EmptyInitList) {
393     // C++1y / DR1070:
394     //   shall be initialized [...] from an empty initializer list.
395     //
396     // We apply the resolution of this DR to C++11 but not C++98, since C++98
397     // does not have useful semantics for initialization from an init list.
398     // We treat this as copy-initialization, because aggregate initialization
399     // always performs copy-initialization on its elements.
400     //
401     // Only do this if we're initializing a class type, to avoid filling in
402     // the initializer list where possible.
403     InitExpr = VerifyOnly ? &DummyInitList : new (SemaRef.Context)
404                    InitListExpr(SemaRef.Context, Loc, None, Loc);
405     InitExpr->setType(SemaRef.Context.VoidTy);
406     SubInit = InitExpr;
407     Kind = InitializationKind::CreateCopy(Loc, Loc);
408   } else {
409     // C++03:
410     //   shall be value-initialized.
411   }
412 
413   InitializationSequence InitSeq(SemaRef, Entity, Kind, SubInit);
414   // libstdc++4.6 marks the vector default constructor as explicit in
415   // _GLIBCXX_DEBUG mode, so recover using the C++03 logic in that case.
416   // stlport does so too. Look for std::__debug for libstdc++, and for
417   // std:: for stlport.  This is effectively a compiler-side implementation of
418   // LWG2193.
419   if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
420           InitializationSequence::FK_ExplicitConstructor) {
421     OverloadCandidateSet::iterator Best;
422     OverloadingResult O =
423         InitSeq.getFailedCandidateSet()
424             .BestViableFunction(SemaRef, Kind.getLocation(), Best);
425     (void)O;
426     assert(O == OR_Success && "Inconsistent overload resolution");
427     CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
428     CXXRecordDecl *R = CtorDecl->getParent();
429 
430     if (CtorDecl->getMinRequiredArguments() == 0 &&
431         CtorDecl->isExplicit() && R->getDeclName() &&
432         SemaRef.SourceMgr.isInSystemHeader(CtorDecl->getLocation())) {
433       bool IsInStd = false;
434       for (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(R->getDeclContext());
435            ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
436         if (SemaRef.getStdNamespace()->InEnclosingNamespaceSetOf(ND))
437           IsInStd = true;
438       }
439 
440       if (IsInStd && llvm::StringSwitch<bool>(R->getName())
441               .Cases("basic_string", "deque", "forward_list", true)
442               .Cases("list", "map", "multimap", "multiset", true)
443               .Cases("priority_queue", "queue", "set", "stack", true)
444               .Cases("unordered_map", "unordered_set", "vector", true)
445               .Default(false)) {
446         InitSeq.InitializeFrom(
447             SemaRef, Entity,
448             InitializationKind::CreateValue(Loc, Loc, Loc, true),
449             MultiExprArg(), /*TopLevelOfInitList=*/false,
450             TreatUnavailableAsInvalid);
451         // Emit a warning for this.  System header warnings aren't shown
452         // by default, but people working on system headers should see it.
453         if (!VerifyOnly) {
454           SemaRef.Diag(CtorDecl->getLocation(),
455                        diag::warn_invalid_initializer_from_system_header);
456           if (Entity.getKind() == InitializedEntity::EK_Member)
457             SemaRef.Diag(Entity.getDecl()->getLocation(),
458                          diag::note_used_in_initialization_here);
459           else if (Entity.getKind() == InitializedEntity::EK_ArrayElement)
460             SemaRef.Diag(Loc, diag::note_used_in_initialization_here);
461         }
462       }
463     }
464   }
465   if (!InitSeq) {
466     if (!VerifyOnly) {
467       InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
468       if (Entity.getKind() == InitializedEntity::EK_Member)
469         SemaRef.Diag(Entity.getDecl()->getLocation(),
470                      diag::note_in_omitted_aggregate_initializer)
471           << /*field*/1 << Entity.getDecl();
472       else if (Entity.getKind() == InitializedEntity::EK_ArrayElement)
473         SemaRef.Diag(Loc, diag::note_in_omitted_aggregate_initializer)
474           << /*array element*/0 << Entity.getElementIndex();
475     }
476     return ExprError();
477   }
478 
479   return VerifyOnly ? ExprResult(static_cast<Expr *>(nullptr))
480                     : InitSeq.Perform(SemaRef, Entity, Kind, SubInit);
481 }
482 
483 void InitListChecker::CheckEmptyInitializable(const InitializedEntity &Entity,
484                                               SourceLocation Loc) {
485   assert(VerifyOnly &&
486          "CheckEmptyInitializable is only inteded for verification mode.");
487   if (PerformEmptyInit(SemaRef, Loc, Entity, /*VerifyOnly*/true,
488                        TreatUnavailableAsInvalid).isInvalid())
489     hadError = true;
490 }
491 
492 void InitListChecker::FillInEmptyInitForBase(
493     unsigned Init, const CXXBaseSpecifier &Base,
494     const InitializedEntity &ParentEntity, InitListExpr *ILE,
495     bool &RequiresSecondPass, bool FillWithNoInit) {
496   assert(Init < ILE->getNumInits() && "should have been expanded");
497 
498   InitializedEntity BaseEntity = InitializedEntity::InitializeBase(
499       SemaRef.Context, &Base, false, &ParentEntity);
500 
501   if (!ILE->getInit(Init)) {
502     ExprResult BaseInit =
503         FillWithNoInit ? new (SemaRef.Context) NoInitExpr(Base.getType())
504                        : PerformEmptyInit(SemaRef, ILE->getLocEnd(), BaseEntity,
505                                           /*VerifyOnly*/ false,
506                                           TreatUnavailableAsInvalid);
507     if (BaseInit.isInvalid()) {
508       hadError = true;
509       return;
510     }
511 
512     ILE->setInit(Init, BaseInit.getAs<Expr>());
513   } else if (InitListExpr *InnerILE =
514                  dyn_cast<InitListExpr>(ILE->getInit(Init))) {
515     FillInEmptyInitializations(BaseEntity, InnerILE,
516                                RequiresSecondPass, FillWithNoInit);
517   } else if (DesignatedInitUpdateExpr *InnerDIUE =
518                dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init))) {
519     FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),
520                                RequiresSecondPass, /*FillWithNoInit =*/true);
521   }
522 }
523 
524 void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
525                                         const InitializedEntity &ParentEntity,
526                                               InitListExpr *ILE,
527                                               bool &RequiresSecondPass,
528                                               bool FillWithNoInit) {
529   SourceLocation Loc = ILE->getLocEnd();
530   unsigned NumInits = ILE->getNumInits();
531   InitializedEntity MemberEntity
532     = InitializedEntity::InitializeMember(Field, &ParentEntity);
533 
534   if (const RecordType *RType = ILE->getType()->getAs<RecordType>())
535     if (!RType->getDecl()->isUnion())
536       assert(Init < NumInits && "This ILE should have been expanded");
537 
538   if (Init >= NumInits || !ILE->getInit(Init)) {
539     if (FillWithNoInit) {
540       Expr *Filler = new (SemaRef.Context) NoInitExpr(Field->getType());
541       if (Init < NumInits)
542         ILE->setInit(Init, Filler);
543       else
544         ILE->updateInit(SemaRef.Context, Init, Filler);
545       return;
546     }
547     // C++1y [dcl.init.aggr]p7:
548     //   If there are fewer initializer-clauses in the list than there are
549     //   members in the aggregate, then each member not explicitly initialized
550     //   shall be initialized from its brace-or-equal-initializer [...]
551     if (Field->hasInClassInitializer()) {
552       ExprResult DIE = SemaRef.BuildCXXDefaultInitExpr(Loc, Field);
553       if (DIE.isInvalid()) {
554         hadError = true;
555         return;
556       }
557       if (Init < NumInits)
558         ILE->setInit(Init, DIE.get());
559       else {
560         ILE->updateInit(SemaRef.Context, Init, DIE.get());
561         RequiresSecondPass = true;
562       }
563       return;
564     }
565 
566     if (Field->getType()->isReferenceType()) {
567       // C++ [dcl.init.aggr]p9:
568       //   If an incomplete or empty initializer-list leaves a
569       //   member of reference type uninitialized, the program is
570       //   ill-formed.
571       SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
572         << Field->getType()
573         << ILE->getSyntacticForm()->getSourceRange();
574       SemaRef.Diag(Field->getLocation(),
575                    diag::note_uninit_reference_member);
576       hadError = true;
577       return;
578     }
579 
580     ExprResult MemberInit = PerformEmptyInit(SemaRef, Loc, MemberEntity,
581                                              /*VerifyOnly*/false,
582                                              TreatUnavailableAsInvalid);
583     if (MemberInit.isInvalid()) {
584       hadError = true;
585       return;
586     }
587 
588     if (hadError) {
589       // Do nothing
590     } else if (Init < NumInits) {
591       ILE->setInit(Init, MemberInit.getAs<Expr>());
592     } else if (!isa<ImplicitValueInitExpr>(MemberInit.get())) {
593       // Empty initialization requires a constructor call, so
594       // extend the initializer list to include the constructor
595       // call and make a note that we'll need to take another pass
596       // through the initializer list.
597       ILE->updateInit(SemaRef.Context, Init, MemberInit.getAs<Expr>());
598       RequiresSecondPass = true;
599     }
600   } else if (InitListExpr *InnerILE
601                = dyn_cast<InitListExpr>(ILE->getInit(Init)))
602     FillInEmptyInitializations(MemberEntity, InnerILE,
603                                RequiresSecondPass, FillWithNoInit);
604   else if (DesignatedInitUpdateExpr *InnerDIUE
605                = dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init)))
606     FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
607                                RequiresSecondPass, /*FillWithNoInit =*/ true);
608 }
609 
610 /// Recursively replaces NULL values within the given initializer list
611 /// with expressions that perform value-initialization of the
612 /// appropriate type.
613 void
614 InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity,
615                                             InitListExpr *ILE,
616                                             bool &RequiresSecondPass,
617                                             bool FillWithNoInit) {
618   assert((ILE->getType() != SemaRef.Context.VoidTy) &&
619          "Should not have void type");
620 
621   if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
622     const RecordDecl *RDecl = RType->getDecl();
623     if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())
624       FillInEmptyInitForField(0, ILE->getInitializedFieldInUnion(),
625                               Entity, ILE, RequiresSecondPass, FillWithNoInit);
626     else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
627              cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
628       for (auto *Field : RDecl->fields()) {
629         if (Field->hasInClassInitializer()) {
630           FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass,
631                                   FillWithNoInit);
632           break;
633         }
634       }
635     } else {
636       // The fields beyond ILE->getNumInits() are default initialized, so in
637       // order to leave them uninitialized, the ILE is expanded and the extra
638       // fields are then filled with NoInitExpr.
639       unsigned NumElems = numStructUnionElements(ILE->getType());
640       if (RDecl->hasFlexibleArrayMember())
641         ++NumElems;
642       if (ILE->getNumInits() < NumElems)
643         ILE->resizeInits(SemaRef.Context, NumElems);
644 
645       unsigned Init = 0;
646 
647       if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {
648         for (auto &Base : CXXRD->bases()) {
649           if (hadError)
650             return;
651 
652           FillInEmptyInitForBase(Init, Base, Entity, ILE, RequiresSecondPass,
653                                  FillWithNoInit);
654           ++Init;
655         }
656       }
657 
658       for (auto *Field : RDecl->fields()) {
659         if (Field->isUnnamedBitfield())
660           continue;
661 
662         if (hadError)
663           return;
664 
665         FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass,
666                                 FillWithNoInit);
667         if (hadError)
668           return;
669 
670         ++Init;
671 
672         // Only look at the first initialization of a union.
673         if (RDecl->isUnion())
674           break;
675       }
676     }
677 
678     return;
679   }
680 
681   QualType ElementType;
682 
683   InitializedEntity ElementEntity = Entity;
684   unsigned NumInits = ILE->getNumInits();
685   unsigned NumElements = NumInits;
686   if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
687     ElementType = AType->getElementType();
688     if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
689       NumElements = CAType->getSize().getZExtValue();
690     ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
691                                                          0, Entity);
692   } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
693     ElementType = VType->getElementType();
694     NumElements = VType->getNumElements();
695     ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
696                                                          0, Entity);
697   } else
698     ElementType = ILE->getType();
699 
700   for (unsigned Init = 0; Init != NumElements; ++Init) {
701     if (hadError)
702       return;
703 
704     if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
705         ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
706       ElementEntity.setElementIndex(Init);
707 
708     Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr);
709     if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
710       ILE->setInit(Init, ILE->getArrayFiller());
711     else if (!InitExpr && !ILE->hasArrayFiller()) {
712       Expr *Filler = nullptr;
713 
714       if (FillWithNoInit)
715         Filler = new (SemaRef.Context) NoInitExpr(ElementType);
716       else {
717         ExprResult ElementInit = PerformEmptyInit(SemaRef, ILE->getLocEnd(),
718                                                   ElementEntity,
719                                                   /*VerifyOnly*/false,
720                                                   TreatUnavailableAsInvalid);
721         if (ElementInit.isInvalid()) {
722           hadError = true;
723           return;
724         }
725 
726         Filler = ElementInit.getAs<Expr>();
727       }
728 
729       if (hadError) {
730         // Do nothing
731       } else if (Init < NumInits) {
732         // For arrays, just set the expression used for value-initialization
733         // of the "holes" in the array.
734         if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
735           ILE->setArrayFiller(Filler);
736         else
737           ILE->setInit(Init, Filler);
738       } else {
739         // For arrays, just set the expression used for value-initialization
740         // of the rest of elements and exit.
741         if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
742           ILE->setArrayFiller(Filler);
743           return;
744         }
745 
746         if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {
747           // Empty initialization requires a constructor call, so
748           // extend the initializer list to include the constructor
749           // call and make a note that we'll need to take another pass
750           // through the initializer list.
751           ILE->updateInit(SemaRef.Context, Init, Filler);
752           RequiresSecondPass = true;
753         }
754       }
755     } else if (InitListExpr *InnerILE
756                  = dyn_cast_or_null<InitListExpr>(InitExpr))
757       FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
758                                  FillWithNoInit);
759     else if (DesignatedInitUpdateExpr *InnerDIUE
760                  = dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr))
761       FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
762                                  RequiresSecondPass, /*FillWithNoInit =*/ true);
763   }
764 }
765 
766 InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
767                                  InitListExpr *IL, QualType &T,
768                                  bool VerifyOnly,
769                                  bool TreatUnavailableAsInvalid)
770   : SemaRef(S), VerifyOnly(VerifyOnly),
771     TreatUnavailableAsInvalid(TreatUnavailableAsInvalid) {
772   // FIXME: Check that IL isn't already the semantic form of some other
773   // InitListExpr. If it is, we'd create a broken AST.
774 
775   hadError = false;
776 
777   FullyStructuredList =
778       getStructuredSubobjectInit(IL, 0, T, nullptr, 0, IL->getSourceRange());
779   CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
780                         /*TopLevelObject=*/true);
781 
782   if (!hadError && !VerifyOnly) {
783     bool RequiresSecondPass = false;
784     FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass);
785     if (RequiresSecondPass && !hadError)
786       FillInEmptyInitializations(Entity, FullyStructuredList,
787                                  RequiresSecondPass);
788   }
789 }
790 
791 int InitListChecker::numArrayElements(QualType DeclType) {
792   // FIXME: use a proper constant
793   int maxElements = 0x7FFFFFFF;
794   if (const ConstantArrayType *CAT =
795         SemaRef.Context.getAsConstantArrayType(DeclType)) {
796     maxElements = static_cast<int>(CAT->getSize().getZExtValue());
797   }
798   return maxElements;
799 }
800 
801 int InitListChecker::numStructUnionElements(QualType DeclType) {
802   RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
803   int InitializableMembers = 0;
804   if (auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl))
805     InitializableMembers += CXXRD->getNumBases();
806   for (const auto *Field : structDecl->fields())
807     if (!Field->isUnnamedBitfield())
808       ++InitializableMembers;
809 
810   if (structDecl->isUnion())
811     return std::min(InitializableMembers, 1);
812   return InitializableMembers - structDecl->hasFlexibleArrayMember();
813 }
814 
815 /// Check whether the range of the initializer \p ParentIList from element
816 /// \p Index onwards can be used to initialize an object of type \p T. Update
817 /// \p Index to indicate how many elements of the list were consumed.
818 ///
819 /// This also fills in \p StructuredList, from element \p StructuredIndex
820 /// onwards, with the fully-braced, desugared form of the initialization.
821 void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
822                                             InitListExpr *ParentIList,
823                                             QualType T, unsigned &Index,
824                                             InitListExpr *StructuredList,
825                                             unsigned &StructuredIndex) {
826   int maxElements = 0;
827 
828   if (T->isArrayType())
829     maxElements = numArrayElements(T);
830   else if (T->isRecordType())
831     maxElements = numStructUnionElements(T);
832   else if (T->isVectorType())
833     maxElements = T->getAs<VectorType>()->getNumElements();
834   else
835     llvm_unreachable("CheckImplicitInitList(): Illegal type");
836 
837   if (maxElements == 0) {
838     if (!VerifyOnly)
839       SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
840                    diag::err_implicit_empty_initializer);
841     ++Index;
842     hadError = true;
843     return;
844   }
845 
846   // Build a structured initializer list corresponding to this subobject.
847   InitListExpr *StructuredSubobjectInitList
848     = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
849                                  StructuredIndex,
850           SourceRange(ParentIList->getInit(Index)->getLocStart(),
851                       ParentIList->getSourceRange().getEnd()));
852   unsigned StructuredSubobjectInitIndex = 0;
853 
854   // Check the element types and build the structural subobject.
855   unsigned StartIndex = Index;
856   CheckListElementTypes(Entity, ParentIList, T,
857                         /*SubobjectIsDesignatorContext=*/false, Index,
858                         StructuredSubobjectInitList,
859                         StructuredSubobjectInitIndex);
860 
861   if (!VerifyOnly) {
862     StructuredSubobjectInitList->setType(T);
863 
864     unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
865     // Update the structured sub-object initializer so that it's ending
866     // range corresponds with the end of the last initializer it used.
867     if (EndIndex < ParentIList->getNumInits() &&
868         ParentIList->getInit(EndIndex)) {
869       SourceLocation EndLoc
870         = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
871       StructuredSubobjectInitList->setRBraceLoc(EndLoc);
872     }
873 
874     // Complain about missing braces.
875     if (T->isArrayType() || T->isRecordType()) {
876       SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
877                    diag::warn_missing_braces)
878           << StructuredSubobjectInitList->getSourceRange()
879           << FixItHint::CreateInsertion(
880                  StructuredSubobjectInitList->getLocStart(), "{")
881           << FixItHint::CreateInsertion(
882                  SemaRef.getLocForEndOfToken(
883                      StructuredSubobjectInitList->getLocEnd()),
884                  "}");
885     }
886   }
887 }
888 
889 /// Warn that \p Entity was of scalar type and was initialized by a
890 /// single-element braced initializer list.
891 static void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity,
892                                  SourceRange Braces) {
893   // Don't warn during template instantiation. If the initialization was
894   // non-dependent, we warned during the initial parse; otherwise, the
895   // type might not be scalar in some uses of the template.
896   if (!S.ActiveTemplateInstantiations.empty())
897     return;
898 
899   unsigned DiagID = 0;
900 
901   switch (Entity.getKind()) {
902   case InitializedEntity::EK_VectorElement:
903   case InitializedEntity::EK_ComplexElement:
904   case InitializedEntity::EK_ArrayElement:
905   case InitializedEntity::EK_Parameter:
906   case InitializedEntity::EK_Parameter_CF_Audited:
907   case InitializedEntity::EK_Result:
908     // Extra braces here are suspicious.
909     DiagID = diag::warn_braces_around_scalar_init;
910     break;
911 
912   case InitializedEntity::EK_Member:
913     // Warn on aggregate initialization but not on ctor init list or
914     // default member initializer.
915     if (Entity.getParent())
916       DiagID = diag::warn_braces_around_scalar_init;
917     break;
918 
919   case InitializedEntity::EK_Variable:
920   case InitializedEntity::EK_LambdaCapture:
921     // No warning, might be direct-list-initialization.
922     // FIXME: Should we warn for copy-list-initialization in these cases?
923     break;
924 
925   case InitializedEntity::EK_New:
926   case InitializedEntity::EK_Temporary:
927   case InitializedEntity::EK_CompoundLiteralInit:
928     // No warning, braces are part of the syntax of the underlying construct.
929     break;
930 
931   case InitializedEntity::EK_RelatedResult:
932     // No warning, we already warned when initializing the result.
933     break;
934 
935   case InitializedEntity::EK_Exception:
936   case InitializedEntity::EK_Base:
937   case InitializedEntity::EK_Delegating:
938   case InitializedEntity::EK_BlockElement:
939   case InitializedEntity::EK_Binding:
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             ElemType->isClkEventT()) && "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(),
1980                                     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,
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   case EK_Binding:
2900     return VariableOrMember->getDeclName();
2901 
2902   case EK_LambdaCapture:
2903     return DeclarationName(Capture.VarID);
2904 
2905   case EK_Result:
2906   case EK_Exception:
2907   case EK_New:
2908   case EK_Temporary:
2909   case EK_Base:
2910   case EK_Delegating:
2911   case EK_ArrayElement:
2912   case EK_VectorElement:
2913   case EK_ComplexElement:
2914   case EK_BlockElement:
2915   case EK_CompoundLiteralInit:
2916   case EK_RelatedResult:
2917     return DeclarationName();
2918   }
2919 
2920   llvm_unreachable("Invalid EntityKind!");
2921 }
2922 
2923 ValueDecl *InitializedEntity::getDecl() const {
2924   switch (getKind()) {
2925   case EK_Variable:
2926   case EK_Member:
2927   case EK_Binding:
2928     return VariableOrMember;
2929 
2930   case EK_Parameter:
2931   case EK_Parameter_CF_Audited:
2932     return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2933 
2934   case EK_Result:
2935   case EK_Exception:
2936   case EK_New:
2937   case EK_Temporary:
2938   case EK_Base:
2939   case EK_Delegating:
2940   case EK_ArrayElement:
2941   case EK_VectorElement:
2942   case EK_ComplexElement:
2943   case EK_BlockElement:
2944   case EK_LambdaCapture:
2945   case EK_CompoundLiteralInit:
2946   case EK_RelatedResult:
2947     return nullptr;
2948   }
2949 
2950   llvm_unreachable("Invalid EntityKind!");
2951 }
2952 
2953 bool InitializedEntity::allowsNRVO() const {
2954   switch (getKind()) {
2955   case EK_Result:
2956   case EK_Exception:
2957     return LocAndNRVO.NRVO;
2958 
2959   case EK_Variable:
2960   case EK_Parameter:
2961   case EK_Parameter_CF_Audited:
2962   case EK_Member:
2963   case EK_Binding:
2964   case EK_New:
2965   case EK_Temporary:
2966   case EK_CompoundLiteralInit:
2967   case EK_Base:
2968   case EK_Delegating:
2969   case EK_ArrayElement:
2970   case EK_VectorElement:
2971   case EK_ComplexElement:
2972   case EK_BlockElement:
2973   case EK_LambdaCapture:
2974   case EK_RelatedResult:
2975     break;
2976   }
2977 
2978   return false;
2979 }
2980 
2981 unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
2982   assert(getParent() != this);
2983   unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
2984   for (unsigned I = 0; I != Depth; ++I)
2985     OS << "`-";
2986 
2987   switch (getKind()) {
2988   case EK_Variable: OS << "Variable"; break;
2989   case EK_Parameter: OS << "Parameter"; break;
2990   case EK_Parameter_CF_Audited: OS << "CF audited function Parameter";
2991     break;
2992   case EK_Result: OS << "Result"; break;
2993   case EK_Exception: OS << "Exception"; break;
2994   case EK_Member: OS << "Member"; break;
2995   case EK_Binding: OS << "Binding"; break;
2996   case EK_New: OS << "New"; break;
2997   case EK_Temporary: OS << "Temporary"; break;
2998   case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
2999   case EK_RelatedResult: OS << "RelatedResult"; break;
3000   case EK_Base: OS << "Base"; break;
3001   case EK_Delegating: OS << "Delegating"; break;
3002   case EK_ArrayElement: OS << "ArrayElement " << Index; break;
3003   case EK_VectorElement: OS << "VectorElement " << Index; break;
3004   case EK_ComplexElement: OS << "ComplexElement " << Index; break;
3005   case EK_BlockElement: OS << "Block"; break;
3006   case EK_LambdaCapture:
3007     OS << "LambdaCapture ";
3008     OS << DeclarationName(Capture.VarID);
3009     break;
3010   }
3011 
3012   if (auto *D = getDecl()) {
3013     OS << " ";
3014     D->printQualifiedName(OS);
3015   }
3016 
3017   OS << " '" << getType().getAsString() << "'\n";
3018 
3019   return Depth + 1;
3020 }
3021 
3022 LLVM_DUMP_METHOD void InitializedEntity::dump() const {
3023   dumpImpl(llvm::errs());
3024 }
3025 
3026 //===----------------------------------------------------------------------===//
3027 // Initialization sequence
3028 //===----------------------------------------------------------------------===//
3029 
3030 void InitializationSequence::Step::Destroy() {
3031   switch (Kind) {
3032   case SK_ResolveAddressOfOverloadedFunction:
3033   case SK_CastDerivedToBaseRValue:
3034   case SK_CastDerivedToBaseXValue:
3035   case SK_CastDerivedToBaseLValue:
3036   case SK_BindReference:
3037   case SK_BindReferenceToTemporary:
3038   case SK_ExtraneousCopyToTemporary:
3039   case SK_UserConversion:
3040   case SK_QualificationConversionRValue:
3041   case SK_QualificationConversionXValue:
3042   case SK_QualificationConversionLValue:
3043   case SK_AtomicConversion:
3044   case SK_LValueToRValue:
3045   case SK_ListInitialization:
3046   case SK_UnwrapInitList:
3047   case SK_RewrapInitList:
3048   case SK_ConstructorInitialization:
3049   case SK_ConstructorInitializationFromList:
3050   case SK_ZeroInitialization:
3051   case SK_CAssignment:
3052   case SK_StringInit:
3053   case SK_ObjCObjectConversion:
3054   case SK_ArrayInit:
3055   case SK_ParenthesizedArrayInit:
3056   case SK_PassByIndirectCopyRestore:
3057   case SK_PassByIndirectRestore:
3058   case SK_ProduceObjCObject:
3059   case SK_StdInitializerList:
3060   case SK_StdInitializerListConstructorCall:
3061   case SK_OCLSamplerInit:
3062   case SK_OCLZeroEvent:
3063     break;
3064 
3065   case SK_ConversionSequence:
3066   case SK_ConversionSequenceNoNarrowing:
3067     delete ICS;
3068   }
3069 }
3070 
3071 bool InitializationSequence::isDirectReferenceBinding() const {
3072   return !Steps.empty() && Steps.back().Kind == SK_BindReference;
3073 }
3074 
3075 bool InitializationSequence::isAmbiguous() const {
3076   if (!Failed())
3077     return false;
3078 
3079   switch (getFailureKind()) {
3080   case FK_TooManyInitsForReference:
3081   case FK_ArrayNeedsInitList:
3082   case FK_ArrayNeedsInitListOrStringLiteral:
3083   case FK_ArrayNeedsInitListOrWideStringLiteral:
3084   case FK_NarrowStringIntoWideCharArray:
3085   case FK_WideStringIntoCharArray:
3086   case FK_IncompatWideStringIntoWideChar:
3087   case FK_AddressOfOverloadFailed: // FIXME: Could do better
3088   case FK_NonConstLValueReferenceBindingToTemporary:
3089   case FK_NonConstLValueReferenceBindingToUnrelated:
3090   case FK_RValueReferenceBindingToLValue:
3091   case FK_ReferenceInitDropsQualifiers:
3092   case FK_ReferenceInitFailed:
3093   case FK_ConversionFailed:
3094   case FK_ConversionFromPropertyFailed:
3095   case FK_TooManyInitsForScalar:
3096   case FK_ReferenceBindingToInitList:
3097   case FK_InitListBadDestinationType:
3098   case FK_DefaultInitOfConst:
3099   case FK_Incomplete:
3100   case FK_ArrayTypeMismatch:
3101   case FK_NonConstantArrayInit:
3102   case FK_ListInitializationFailed:
3103   case FK_VariableLengthArrayHasInitializer:
3104   case FK_PlaceholderType:
3105   case FK_ExplicitConstructor:
3106   case FK_AddressOfUnaddressableFunction:
3107     return false;
3108 
3109   case FK_ReferenceInitOverloadFailed:
3110   case FK_UserConversionOverloadFailed:
3111   case FK_ConstructorOverloadFailed:
3112   case FK_ListConstructorOverloadFailed:
3113     return FailedOverloadResult == OR_Ambiguous;
3114   }
3115 
3116   llvm_unreachable("Invalid EntityKind!");
3117 }
3118 
3119 bool InitializationSequence::isConstructorInitialization() const {
3120   return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
3121 }
3122 
3123 void
3124 InitializationSequence
3125 ::AddAddressOverloadResolutionStep(FunctionDecl *Function,
3126                                    DeclAccessPair Found,
3127                                    bool HadMultipleCandidates) {
3128   Step S;
3129   S.Kind = SK_ResolveAddressOfOverloadedFunction;
3130   S.Type = Function->getType();
3131   S.Function.HadMultipleCandidates = HadMultipleCandidates;
3132   S.Function.Function = Function;
3133   S.Function.FoundDecl = Found;
3134   Steps.push_back(S);
3135 }
3136 
3137 void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
3138                                                       ExprValueKind VK) {
3139   Step S;
3140   switch (VK) {
3141   case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
3142   case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
3143   case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
3144   }
3145   S.Type = BaseType;
3146   Steps.push_back(S);
3147 }
3148 
3149 void InitializationSequence::AddReferenceBindingStep(QualType T,
3150                                                      bool BindingTemporary) {
3151   Step S;
3152   S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
3153   S.Type = T;
3154   Steps.push_back(S);
3155 }
3156 
3157 void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) {
3158   Step S;
3159   S.Kind = SK_ExtraneousCopyToTemporary;
3160   S.Type = T;
3161   Steps.push_back(S);
3162 }
3163 
3164 void
3165 InitializationSequence::AddUserConversionStep(FunctionDecl *Function,
3166                                               DeclAccessPair FoundDecl,
3167                                               QualType T,
3168                                               bool HadMultipleCandidates) {
3169   Step S;
3170   S.Kind = SK_UserConversion;
3171   S.Type = T;
3172   S.Function.HadMultipleCandidates = HadMultipleCandidates;
3173   S.Function.Function = Function;
3174   S.Function.FoundDecl = FoundDecl;
3175   Steps.push_back(S);
3176 }
3177 
3178 void InitializationSequence::AddQualificationConversionStep(QualType Ty,
3179                                                             ExprValueKind VK) {
3180   Step S;
3181   S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
3182   switch (VK) {
3183   case VK_RValue:
3184     S.Kind = SK_QualificationConversionRValue;
3185     break;
3186   case VK_XValue:
3187     S.Kind = SK_QualificationConversionXValue;
3188     break;
3189   case VK_LValue:
3190     S.Kind = SK_QualificationConversionLValue;
3191     break;
3192   }
3193   S.Type = Ty;
3194   Steps.push_back(S);
3195 }
3196 
3197 void InitializationSequence::AddAtomicConversionStep(QualType Ty) {
3198   Step S;
3199   S.Kind = SK_AtomicConversion;
3200   S.Type = Ty;
3201   Steps.push_back(S);
3202 }
3203 
3204 void InitializationSequence::AddLValueToRValueStep(QualType Ty) {
3205   assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
3206 
3207   Step S;
3208   S.Kind = SK_LValueToRValue;
3209   S.Type = Ty;
3210   Steps.push_back(S);
3211 }
3212 
3213 void InitializationSequence::AddConversionSequenceStep(
3214     const ImplicitConversionSequence &ICS, QualType T,
3215     bool TopLevelOfInitList) {
3216   Step S;
3217   S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing
3218                               : SK_ConversionSequence;
3219   S.Type = T;
3220   S.ICS = new ImplicitConversionSequence(ICS);
3221   Steps.push_back(S);
3222 }
3223 
3224 void InitializationSequence::AddListInitializationStep(QualType T) {
3225   Step S;
3226   S.Kind = SK_ListInitialization;
3227   S.Type = T;
3228   Steps.push_back(S);
3229 }
3230 
3231 void InitializationSequence::AddConstructorInitializationStep(
3232     DeclAccessPair FoundDecl, CXXConstructorDecl *Constructor, QualType T,
3233     bool HadMultipleCandidates, 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 = FoundDecl;
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 /// Determine if the constructor has the signature of a copy or move
3442 /// constructor for the type T of the class in which it was found. That is,
3443 /// determine if its first parameter is of type T or reference to (possibly
3444 /// cv-qualified) T.
3445 static bool hasCopyOrMoveCtorParam(ASTContext &Ctx,
3446                                    const ConstructorInfo &Info) {
3447   if (Info.Constructor->getNumParams() == 0)
3448     return false;
3449 
3450   QualType ParmT =
3451       Info.Constructor->getParamDecl(0)->getType().getNonReferenceType();
3452   QualType ClassT =
3453       Ctx.getRecordType(cast<CXXRecordDecl>(Info.FoundDecl->getDeclContext()));
3454 
3455   return Ctx.hasSameUnqualifiedType(ParmT, ClassT);
3456 }
3457 
3458 static OverloadingResult
3459 ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc,
3460                            MultiExprArg Args,
3461                            OverloadCandidateSet &CandidateSet,
3462                            DeclContext::lookup_result Ctors,
3463                            OverloadCandidateSet::iterator &Best,
3464                            bool CopyInitializing, bool AllowExplicit,
3465                            bool OnlyListConstructors, bool IsListInit,
3466                            bool SecondStepOfCopyInit = false) {
3467   CandidateSet.clear();
3468 
3469   for (NamedDecl *D : Ctors) {
3470     auto Info = getConstructorInfo(D);
3471     if (!Info.Constructor || Info.Constructor->isInvalidDecl())
3472       continue;
3473 
3474     if (!AllowExplicit && Info.Constructor->isExplicit())
3475       continue;
3476 
3477     if (OnlyListConstructors && !S.isInitListConstructor(Info.Constructor))
3478       continue;
3479 
3480     // C++11 [over.best.ics]p4:
3481     //   ... and the constructor or user-defined conversion function is a
3482     //   candidate by
3483     //   - 13.3.1.3, when the argument is the temporary in the second step
3484     //     of a class copy-initialization, or
3485     //   - 13.3.1.4, 13.3.1.5, or 13.3.1.6 (in all cases), [not handled here]
3486     //   - the second phase of 13.3.1.7 when the initializer list has exactly
3487     //     one element that is itself an initializer list, and the target is
3488     //     the first parameter of a constructor of class X, and the conversion
3489     //     is to X or reference to (possibly cv-qualified X),
3490     //   user-defined conversion sequences are not considered.
3491     bool SuppressUserConversions =
3492         SecondStepOfCopyInit ||
3493         (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
3494          hasCopyOrMoveCtorParam(S.Context, Info));
3495 
3496     if (Info.ConstructorTmpl)
3497       S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
3498                                      /*ExplicitArgs*/ nullptr, Args,
3499                                      CandidateSet, SuppressUserConversions);
3500     else {
3501       // C++ [over.match.copy]p1:
3502       //   - When initializing a temporary to be bound to the first parameter
3503       //     of a constructor [for type T] that takes a reference to possibly
3504       //     cv-qualified T as its first argument, called with a single
3505       //     argument in the context of direct-initialization, explicit
3506       //     conversion functions are also considered.
3507       // FIXME: What if a constructor template instantiates to such a signature?
3508       bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
3509                                Args.size() == 1 &&
3510                                hasCopyOrMoveCtorParam(S.Context, Info);
3511       S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, Args,
3512                              CandidateSet, SuppressUserConversions,
3513                              /*PartialOverloading=*/false,
3514                              /*AllowExplicit=*/AllowExplicitConv);
3515     }
3516   }
3517 
3518   // Perform overload resolution and return the result.
3519   return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3520 }
3521 
3522 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3523 /// enumerates the constructors of the initialized entity and performs overload
3524 /// resolution to select the best.
3525 /// \param IsListInit     Is this list-initialization?
3526 /// \param IsInitListCopy Is this non-list-initialization resulting from a
3527 ///                       list-initialization from {x} where x is the same
3528 ///                       type as the entity?
3529 static void TryConstructorInitialization(Sema &S,
3530                                          const InitializedEntity &Entity,
3531                                          const InitializationKind &Kind,
3532                                          MultiExprArg Args, QualType DestType,
3533                                          InitializationSequence &Sequence,
3534                                          bool IsListInit = false,
3535                                          bool IsInitListCopy = false) {
3536   assert((!IsListInit || (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
3537          "IsListInit must come with a single initializer list argument.");
3538 
3539   // The type we're constructing needs to be complete.
3540   if (!S.isCompleteType(Kind.getLocation(), DestType)) {
3541     Sequence.setIncompleteTypeFailure(DestType);
3542     return;
3543   }
3544 
3545   const RecordType *DestRecordType = DestType->getAs<RecordType>();
3546   assert(DestRecordType && "Constructor initialization requires record type");
3547   CXXRecordDecl *DestRecordDecl
3548     = cast<CXXRecordDecl>(DestRecordType->getDecl());
3549 
3550   // Build the candidate set directly in the initialization sequence
3551   // structure, so that it will persist if we fail.
3552   OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3553 
3554   // Determine whether we are allowed to call explicit constructors or
3555   // explicit conversion operators.
3556   bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
3557   bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
3558 
3559   //   - Otherwise, if T is a class type, constructors are considered. The
3560   //     applicable constructors are enumerated, and the best one is chosen
3561   //     through overload resolution.
3562   DeclContext::lookup_result Ctors = S.LookupConstructors(DestRecordDecl);
3563 
3564   OverloadingResult Result = OR_No_Viable_Function;
3565   OverloadCandidateSet::iterator Best;
3566   bool AsInitializerList = false;
3567 
3568   // C++11 [over.match.list]p1, per DR1467:
3569   //   When objects of non-aggregate type T are list-initialized, such that
3570   //   8.5.4 [dcl.init.list] specifies that overload resolution is performed
3571   //   according to the rules in this section, overload resolution selects
3572   //   the constructor in two phases:
3573   //
3574   //   - Initially, the candidate functions are the initializer-list
3575   //     constructors of the class T and the argument list consists of the
3576   //     initializer list as a single argument.
3577   if (IsListInit) {
3578     InitListExpr *ILE = cast<InitListExpr>(Args[0]);
3579     AsInitializerList = true;
3580 
3581     // If the initializer list has no elements and T has a default constructor,
3582     // the first phase is omitted.
3583     if (ILE->getNumInits() != 0 || !DestRecordDecl->hasDefaultConstructor())
3584       Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3585                                           CandidateSet, Ctors, Best,
3586                                           CopyInitialization, AllowExplicit,
3587                                           /*OnlyListConstructor=*/true,
3588                                           IsListInit);
3589 
3590     // Time to unwrap the init list.
3591     Args = MultiExprArg(ILE->getInits(), ILE->getNumInits());
3592   }
3593 
3594   // C++11 [over.match.list]p1:
3595   //   - If no viable initializer-list constructor is found, overload resolution
3596   //     is performed again, where the candidate functions are all the
3597   //     constructors of the class T and the argument list consists of the
3598   //     elements of the initializer list.
3599   if (Result == OR_No_Viable_Function) {
3600     AsInitializerList = false;
3601     Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3602                                         CandidateSet, Ctors, Best,
3603                                         CopyInitialization, AllowExplicit,
3604                                         /*OnlyListConstructors=*/false,
3605                                         IsListInit);
3606   }
3607   if (Result) {
3608     Sequence.SetOverloadFailure(IsListInit ?
3609                       InitializationSequence::FK_ListConstructorOverloadFailed :
3610                       InitializationSequence::FK_ConstructorOverloadFailed,
3611                                 Result);
3612     return;
3613   }
3614 
3615   // C++11 [dcl.init]p6:
3616   //   If a program calls for the default initialization of an object
3617   //   of a const-qualified type T, T shall be a class type with a
3618   //   user-provided default constructor.
3619   // C++ core issue 253 proposal:
3620   //   If the implicit default constructor initializes all subobjects, no
3621   //   initializer should be required.
3622   // The 253 proposal is for example needed to process libstdc++ headers in 5.x.
3623   CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3624   if (Kind.getKind() == InitializationKind::IK_Default &&
3625       Entity.getType().isConstQualified()) {
3626     if (!CtorDecl->getParent()->allowConstDefaultInit()) {
3627       if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
3628         Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
3629       return;
3630     }
3631   }
3632 
3633   // C++11 [over.match.list]p1:
3634   //   In copy-list-initialization, if an explicit constructor is chosen, the
3635   //   initializer is ill-formed.
3636   if (IsListInit && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3637     Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor);
3638     return;
3639   }
3640 
3641   // Add the constructor initialization step. Any cv-qualification conversion is
3642   // subsumed by the initialization.
3643   bool HadMultipleCandidates = (CandidateSet.size() > 1);
3644   Sequence.AddConstructorInitializationStep(
3645       Best->FoundDecl, CtorDecl, DestType, HadMultipleCandidates,
3646       IsListInit | IsInitListCopy, AsInitializerList);
3647 }
3648 
3649 static bool
3650 ResolveOverloadedFunctionForReferenceBinding(Sema &S,
3651                                              Expr *Initializer,
3652                                              QualType &SourceType,
3653                                              QualType &UnqualifiedSourceType,
3654                                              QualType UnqualifiedTargetType,
3655                                              InitializationSequence &Sequence) {
3656   if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
3657         S.Context.OverloadTy) {
3658     DeclAccessPair Found;
3659     bool HadMultipleCandidates = false;
3660     if (FunctionDecl *Fn
3661         = S.ResolveAddressOfOverloadedFunction(Initializer,
3662                                                UnqualifiedTargetType,
3663                                                false, Found,
3664                                                &HadMultipleCandidates)) {
3665       Sequence.AddAddressOverloadResolutionStep(Fn, Found,
3666                                                 HadMultipleCandidates);
3667       SourceType = Fn->getType();
3668       UnqualifiedSourceType = SourceType.getUnqualifiedType();
3669     } else if (!UnqualifiedTargetType->isRecordType()) {
3670       Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3671       return true;
3672     }
3673   }
3674   return false;
3675 }
3676 
3677 static void TryReferenceInitializationCore(Sema &S,
3678                                            const InitializedEntity &Entity,
3679                                            const InitializationKind &Kind,
3680                                            Expr *Initializer,
3681                                            QualType cv1T1, QualType T1,
3682                                            Qualifiers T1Quals,
3683                                            QualType cv2T2, QualType T2,
3684                                            Qualifiers T2Quals,
3685                                            InitializationSequence &Sequence);
3686 
3687 static void TryValueInitialization(Sema &S,
3688                                    const InitializedEntity &Entity,
3689                                    const InitializationKind &Kind,
3690                                    InitializationSequence &Sequence,
3691                                    InitListExpr *InitList = nullptr);
3692 
3693 /// \brief Attempt list initialization of a reference.
3694 static void TryReferenceListInitialization(Sema &S,
3695                                            const InitializedEntity &Entity,
3696                                            const InitializationKind &Kind,
3697                                            InitListExpr *InitList,
3698                                            InitializationSequence &Sequence,
3699                                            bool TreatUnavailableAsInvalid) {
3700   // First, catch C++03 where this isn't possible.
3701   if (!S.getLangOpts().CPlusPlus11) {
3702     Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
3703     return;
3704   }
3705   // Can't reference initialize a compound literal.
3706   if (Entity.getKind() == InitializedEntity::EK_CompoundLiteralInit) {
3707     Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
3708     return;
3709   }
3710 
3711   QualType DestType = Entity.getType();
3712   QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3713   Qualifiers T1Quals;
3714   QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3715 
3716   // Reference initialization via an initializer list works thus:
3717   // If the initializer list consists of a single element that is
3718   // reference-related to the referenced type, bind directly to that element
3719   // (possibly creating temporaries).
3720   // Otherwise, initialize a temporary with the initializer list and
3721   // bind to that.
3722   if (InitList->getNumInits() == 1) {
3723     Expr *Initializer = InitList->getInit(0);
3724     QualType cv2T2 = Initializer->getType();
3725     Qualifiers T2Quals;
3726     QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3727 
3728     // If this fails, creating a temporary wouldn't work either.
3729     if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3730                                                      T1, Sequence))
3731       return;
3732 
3733     SourceLocation DeclLoc = Initializer->getLocStart();
3734     bool dummy1, dummy2, dummy3;
3735     Sema::ReferenceCompareResult RefRelationship
3736       = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3737                                        dummy2, dummy3);
3738     if (RefRelationship >= Sema::Ref_Related) {
3739       // Try to bind the reference here.
3740       TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3741                                      T1Quals, cv2T2, T2, T2Quals, Sequence);
3742       if (Sequence)
3743         Sequence.RewrapReferenceInitList(cv1T1, InitList);
3744       return;
3745     }
3746 
3747     // Update the initializer if we've resolved an overloaded function.
3748     if (Sequence.step_begin() != Sequence.step_end())
3749       Sequence.RewrapReferenceInitList(cv1T1, InitList);
3750   }
3751 
3752   // Not reference-related. Create a temporary and bind to that.
3753   InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3754 
3755   TryListInitialization(S, TempEntity, Kind, InitList, Sequence,
3756                         TreatUnavailableAsInvalid);
3757   if (Sequence) {
3758     if (DestType->isRValueReferenceType() ||
3759         (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3760       Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3761     else
3762       Sequence.SetFailed(
3763           InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
3764   }
3765 }
3766 
3767 /// \brief Attempt list initialization (C++0x [dcl.init.list])
3768 static void TryListInitialization(Sema &S,
3769                                   const InitializedEntity &Entity,
3770                                   const InitializationKind &Kind,
3771                                   InitListExpr *InitList,
3772                                   InitializationSequence &Sequence,
3773                                   bool TreatUnavailableAsInvalid) {
3774   QualType DestType = Entity.getType();
3775 
3776   // C++ doesn't allow scalar initialization with more than one argument.
3777   // But C99 complex numbers are scalars and it makes sense there.
3778   if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
3779       !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
3780     Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar);
3781     return;
3782   }
3783   if (DestType->isReferenceType()) {
3784     TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence,
3785                                    TreatUnavailableAsInvalid);
3786     return;
3787   }
3788 
3789   if (DestType->isRecordType() &&
3790       !S.isCompleteType(InitList->getLocStart(), DestType)) {
3791     Sequence.setIncompleteTypeFailure(DestType);
3792     return;
3793   }
3794 
3795   // C++11 [dcl.init.list]p3, per DR1467:
3796   // - If T is a class type and the initializer list has a single element of
3797   //   type cv U, where U is T or a class derived from T, the object is
3798   //   initialized from that element (by copy-initialization for
3799   //   copy-list-initialization, or by direct-initialization for
3800   //   direct-list-initialization).
3801   // - Otherwise, if T is a character array and the initializer list has a
3802   //   single element that is an appropriately-typed string literal
3803   //   (8.5.2 [dcl.init.string]), initialization is performed as described
3804   //   in that section.
3805   // - Otherwise, if T is an aggregate, [...] (continue below).
3806   if (S.getLangOpts().CPlusPlus11 && InitList->getNumInits() == 1) {
3807     if (DestType->isRecordType()) {
3808       QualType InitType = InitList->getInit(0)->getType();
3809       if (S.Context.hasSameUnqualifiedType(InitType, DestType) ||
3810           S.IsDerivedFrom(InitList->getLocStart(), InitType, DestType)) {
3811         Expr *InitAsExpr = InitList->getInit(0);
3812         TryConstructorInitialization(S, Entity, Kind, InitAsExpr, DestType,
3813                                      Sequence, /*InitListSyntax*/ false,
3814                                      /*IsInitListCopy*/ true);
3815         return;
3816       }
3817     }
3818     if (const ArrayType *DestAT = S.Context.getAsArrayType(DestType)) {
3819       Expr *SubInit[1] = {InitList->getInit(0)};
3820       if (!isa<VariableArrayType>(DestAT) &&
3821           IsStringInit(SubInit[0], DestAT, S.Context) == SIF_None) {
3822         InitializationKind SubKind =
3823             Kind.getKind() == InitializationKind::IK_DirectList
3824                 ? InitializationKind::CreateDirect(Kind.getLocation(),
3825                                                    InitList->getLBraceLoc(),
3826                                                    InitList->getRBraceLoc())
3827                 : Kind;
3828         Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3829                                 /*TopLevelOfInitList*/ true,
3830                                 TreatUnavailableAsInvalid);
3831 
3832         // TryStringLiteralInitialization() (in InitializeFrom()) will fail if
3833         // the element is not an appropriately-typed string literal, in which
3834         // case we should proceed as in C++11 (below).
3835         if (Sequence) {
3836           Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3837           return;
3838         }
3839       }
3840     }
3841   }
3842 
3843   // C++11 [dcl.init.list]p3:
3844   //   - If T is an aggregate, aggregate initialization is performed.
3845   if ((DestType->isRecordType() && !DestType->isAggregateType()) ||
3846       (S.getLangOpts().CPlusPlus11 &&
3847        S.isStdInitializerList(DestType, nullptr))) {
3848     if (S.getLangOpts().CPlusPlus11) {
3849       //   - Otherwise, if the initializer list has no elements and T is a
3850       //     class type with a default constructor, the object is
3851       //     value-initialized.
3852       if (InitList->getNumInits() == 0) {
3853         CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
3854         if (RD->hasDefaultConstructor()) {
3855           TryValueInitialization(S, Entity, Kind, Sequence, InitList);
3856           return;
3857         }
3858       }
3859 
3860       //   - Otherwise, if T is a specialization of std::initializer_list<E>,
3861       //     an initializer_list object constructed [...]
3862       if (TryInitializerListConstruction(S, InitList, DestType, Sequence,
3863                                          TreatUnavailableAsInvalid))
3864         return;
3865 
3866       //   - Otherwise, if T is a class type, constructors are considered.
3867       Expr *InitListAsExpr = InitList;
3868       TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
3869                                    Sequence, /*InitListSyntax*/ true);
3870     } else
3871       Sequence.SetFailed(InitializationSequence::FK_InitListBadDestinationType);
3872     return;
3873   }
3874 
3875   if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() &&
3876       InitList->getNumInits() == 1) {
3877     Expr *E = InitList->getInit(0);
3878 
3879     //   - Otherwise, if T is an enumeration with a fixed underlying type,
3880     //     the initializer-list has a single element v, and the initialization
3881     //     is direct-list-initialization, the object is initialized with the
3882     //     value T(v); if a narrowing conversion is required to convert v to
3883     //     the underlying type of T, the program is ill-formed.
3884     auto *ET = DestType->getAs<EnumType>();
3885     if (S.getLangOpts().CPlusPlus1z &&
3886         Kind.getKind() == InitializationKind::IK_DirectList &&
3887         ET && ET->getDecl()->isFixed() &&
3888         !S.Context.hasSameUnqualifiedType(E->getType(), DestType) &&
3889         (E->getType()->isIntegralOrEnumerationType() ||
3890          E->getType()->isFloatingType())) {
3891       // There are two ways that T(v) can work when T is an enumeration type.
3892       // If there is either an implicit conversion sequence from v to T or
3893       // a conversion function that can convert from v to T, then we use that.
3894       // Otherwise, if v is of integral, enumeration, or floating-point type,
3895       // it is converted to the enumeration type via its underlying type.
3896       // There is no overlap possible between these two cases (except when the
3897       // source value is already of the destination type), and the first
3898       // case is handled by the general case for single-element lists below.
3899       ImplicitConversionSequence ICS;
3900       ICS.setStandard();
3901       ICS.Standard.setAsIdentityConversion();
3902       // If E is of a floating-point type, then the conversion is ill-formed
3903       // due to narrowing, but go through the motions in order to produce the
3904       // right diagnostic.
3905       ICS.Standard.Second = E->getType()->isFloatingType()
3906                                 ? ICK_Floating_Integral
3907                                 : ICK_Integral_Conversion;
3908       ICS.Standard.setFromType(E->getType());
3909       ICS.Standard.setToType(0, E->getType());
3910       ICS.Standard.setToType(1, DestType);
3911       ICS.Standard.setToType(2, DestType);
3912       Sequence.AddConversionSequenceStep(ICS, ICS.Standard.getToType(2),
3913                                          /*TopLevelOfInitList*/true);
3914       Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3915       return;
3916     }
3917 
3918     //   - Otherwise, if the initializer list has a single element of type E
3919     //     [...references are handled above...], the object or reference is
3920     //     initialized from that element (by copy-initialization for
3921     //     copy-list-initialization, or by direct-initialization for
3922     //     direct-list-initialization); if a narrowing conversion is required
3923     //     to convert the element to T, the program is ill-formed.
3924     //
3925     // Per core-24034, this is direct-initialization if we were performing
3926     // direct-list-initialization and copy-initialization otherwise.
3927     // We can't use InitListChecker for this, because it always performs
3928     // copy-initialization. This only matters if we might use an 'explicit'
3929     // conversion operator, so we only need to handle the cases where the source
3930     // is of record type.
3931     if (InitList->getInit(0)->getType()->isRecordType()) {
3932       InitializationKind SubKind =
3933           Kind.getKind() == InitializationKind::IK_DirectList
3934               ? InitializationKind::CreateDirect(Kind.getLocation(),
3935                                                  InitList->getLBraceLoc(),
3936                                                  InitList->getRBraceLoc())
3937               : Kind;
3938       Expr *SubInit[1] = { InitList->getInit(0) };
3939       Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3940                               /*TopLevelOfInitList*/true,
3941                               TreatUnavailableAsInvalid);
3942       if (Sequence)
3943         Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3944       return;
3945     }
3946   }
3947 
3948   InitListChecker CheckInitList(S, Entity, InitList,
3949           DestType, /*VerifyOnly=*/true, TreatUnavailableAsInvalid);
3950   if (CheckInitList.HadError()) {
3951     Sequence.SetFailed(InitializationSequence::FK_ListInitializationFailed);
3952     return;
3953   }
3954 
3955   // Add the list initialization step with the built init list.
3956   Sequence.AddListInitializationStep(DestType);
3957 }
3958 
3959 /// \brief Try a reference initialization that involves calling a conversion
3960 /// function.
3961 static OverloadingResult TryRefInitWithConversionFunction(Sema &S,
3962                                              const InitializedEntity &Entity,
3963                                              const InitializationKind &Kind,
3964                                              Expr *Initializer,
3965                                              bool AllowRValues,
3966                                              InitializationSequence &Sequence) {
3967   QualType DestType = Entity.getType();
3968   QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3969   QualType T1 = cv1T1.getUnqualifiedType();
3970   QualType cv2T2 = Initializer->getType();
3971   QualType T2 = cv2T2.getUnqualifiedType();
3972 
3973   bool DerivedToBase;
3974   bool ObjCConversion;
3975   bool ObjCLifetimeConversion;
3976   assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
3977                                          T1, T2, DerivedToBase,
3978                                          ObjCConversion,
3979                                          ObjCLifetimeConversion) &&
3980          "Must have incompatible references when binding via conversion");
3981   (void)DerivedToBase;
3982   (void)ObjCConversion;
3983   (void)ObjCLifetimeConversion;
3984 
3985   // Build the candidate set directly in the initialization sequence
3986   // structure, so that it will persist if we fail.
3987   OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3988   CandidateSet.clear();
3989 
3990   // Determine whether we are allowed to call explicit constructors or
3991   // explicit conversion operators.
3992   bool AllowExplicit = Kind.AllowExplicit();
3993   bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
3994 
3995   const RecordType *T1RecordType = nullptr;
3996   if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
3997       S.isCompleteType(Kind.getLocation(), T1)) {
3998     // The type we're converting to is a class type. Enumerate its constructors
3999     // to see if there is a suitable conversion.
4000     CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
4001 
4002     for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) {
4003       auto Info = getConstructorInfo(D);
4004       if (!Info.Constructor)
4005         continue;
4006 
4007       if (!Info.Constructor->isInvalidDecl() &&
4008           Info.Constructor->isConvertingConstructor(AllowExplicit)) {
4009         if (Info.ConstructorTmpl)
4010           S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
4011                                          /*ExplicitArgs*/ nullptr,
4012                                          Initializer, CandidateSet,
4013                                          /*SuppressUserConversions=*/true);
4014         else
4015           S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
4016                                  Initializer, CandidateSet,
4017                                  /*SuppressUserConversions=*/true);
4018       }
4019     }
4020   }
4021   if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
4022     return OR_No_Viable_Function;
4023 
4024   const RecordType *T2RecordType = nullptr;
4025   if ((T2RecordType = T2->getAs<RecordType>()) &&
4026       S.isCompleteType(Kind.getLocation(), T2)) {
4027     // The type we're converting from is a class type, enumerate its conversion
4028     // functions.
4029     CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
4030 
4031     const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4032     for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4033       NamedDecl *D = *I;
4034       CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4035       if (isa<UsingShadowDecl>(D))
4036         D = cast<UsingShadowDecl>(D)->getTargetDecl();
4037 
4038       FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4039       CXXConversionDecl *Conv;
4040       if (ConvTemplate)
4041         Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4042       else
4043         Conv = cast<CXXConversionDecl>(D);
4044 
4045       // If the conversion function doesn't return a reference type,
4046       // it can't be considered for this conversion unless we're allowed to
4047       // consider rvalues.
4048       // FIXME: Do we need to make sure that we only consider conversion
4049       // candidates with reference-compatible results? That might be needed to
4050       // break recursion.
4051       if ((AllowExplicitConvs || !Conv->isExplicit()) &&
4052           (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
4053         if (ConvTemplate)
4054           S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4055                                            ActingDC, Initializer,
4056                                            DestType, CandidateSet,
4057                                            /*AllowObjCConversionOnExplicit=*/
4058                                              false);
4059         else
4060           S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4061                                    Initializer, DestType, CandidateSet,
4062                                    /*AllowObjCConversionOnExplicit=*/false);
4063       }
4064     }
4065   }
4066   if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
4067     return OR_No_Viable_Function;
4068 
4069   SourceLocation DeclLoc = Initializer->getLocStart();
4070 
4071   // Perform overload resolution. If it fails, return the failed result.
4072   OverloadCandidateSet::iterator Best;
4073   if (OverloadingResult Result
4074         = CandidateSet.BestViableFunction(S, DeclLoc, Best, true))
4075     return Result;
4076 
4077   FunctionDecl *Function = Best->Function;
4078   // This is the overload that will be used for this initialization step if we
4079   // use this initialization. Mark it as referenced.
4080   Function->setReferenced();
4081 
4082   // Compute the returned type of the conversion.
4083   if (isa<CXXConversionDecl>(Function))
4084     T2 = Function->getReturnType();
4085   else
4086     T2 = cv1T1;
4087 
4088   // Add the user-defined conversion step.
4089   bool HadMultipleCandidates = (CandidateSet.size() > 1);
4090   Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4091                                  T2.getNonLValueExprType(S.Context),
4092                                  HadMultipleCandidates);
4093 
4094   // Determine whether we need to perform derived-to-base or
4095   // cv-qualification adjustments.
4096   ExprValueKind VK = VK_RValue;
4097   if (T2->isLValueReferenceType())
4098     VK = VK_LValue;
4099   else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>())
4100     VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
4101 
4102   bool NewDerivedToBase = false;
4103   bool NewObjCConversion = false;
4104   bool NewObjCLifetimeConversion = false;
4105   Sema::ReferenceCompareResult NewRefRelationship
4106     = S.CompareReferenceRelationship(DeclLoc, T1,
4107                                      T2.getNonLValueExprType(S.Context),
4108                                      NewDerivedToBase, NewObjCConversion,
4109                                      NewObjCLifetimeConversion);
4110   if (NewRefRelationship == Sema::Ref_Incompatible) {
4111     // If the type we've converted to is not reference-related to the
4112     // type we're looking for, then there is another conversion step
4113     // we need to perform to produce a temporary of the right type
4114     // that we'll be binding to.
4115     ImplicitConversionSequence ICS;
4116     ICS.setStandard();
4117     ICS.Standard = Best->FinalConversion;
4118     T2 = ICS.Standard.getToType(2);
4119     Sequence.AddConversionSequenceStep(ICS, T2);
4120   } else if (NewDerivedToBase)
4121     Sequence.AddDerivedToBaseCastStep(
4122                                 S.Context.getQualifiedType(T1,
4123                                   T2.getNonReferenceType().getQualifiers()),
4124                                       VK);
4125   else if (NewObjCConversion)
4126     Sequence.AddObjCObjectConversionStep(
4127                                 S.Context.getQualifiedType(T1,
4128                                   T2.getNonReferenceType().getQualifiers()));
4129 
4130   if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers())
4131     Sequence.AddQualificationConversionStep(cv1T1, VK);
4132 
4133   Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType());
4134   return OR_Success;
4135 }
4136 
4137 static void CheckCXX98CompatAccessibleCopy(Sema &S,
4138                                            const InitializedEntity &Entity,
4139                                            Expr *CurInitExpr);
4140 
4141 /// \brief Attempt reference initialization (C++0x [dcl.init.ref])
4142 static void TryReferenceInitialization(Sema &S,
4143                                        const InitializedEntity &Entity,
4144                                        const InitializationKind &Kind,
4145                                        Expr *Initializer,
4146                                        InitializationSequence &Sequence) {
4147   QualType DestType = Entity.getType();
4148   QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
4149   Qualifiers T1Quals;
4150   QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
4151   QualType cv2T2 = Initializer->getType();
4152   Qualifiers T2Quals;
4153   QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
4154 
4155   // If the initializer is the address of an overloaded function, try
4156   // to resolve the overloaded function. If all goes well, T2 is the
4157   // type of the resulting function.
4158   if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
4159                                                    T1, Sequence))
4160     return;
4161 
4162   // Delegate everything else to a subfunction.
4163   TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
4164                                  T1Quals, cv2T2, T2, T2Quals, Sequence);
4165 }
4166 
4167 /// Converts the target of reference initialization so that it has the
4168 /// appropriate qualifiers and value kind.
4169 ///
4170 /// In this case, 'x' is an 'int' lvalue, but it needs to be 'const int'.
4171 /// \code
4172 ///   int x;
4173 ///   const int &r = x;
4174 /// \endcode
4175 ///
4176 /// In this case the reference is binding to a bitfield lvalue, which isn't
4177 /// valid. Perform a load to create a lifetime-extended temporary instead.
4178 /// \code
4179 ///   const int &r = someStruct.bitfield;
4180 /// \endcode
4181 static ExprValueKind
4182 convertQualifiersAndValueKindIfNecessary(Sema &S,
4183                                          InitializationSequence &Sequence,
4184                                          Expr *Initializer,
4185                                          QualType cv1T1,
4186                                          Qualifiers T1Quals,
4187                                          Qualifiers T2Quals,
4188                                          bool IsLValueRef) {
4189   bool IsNonAddressableType = Initializer->refersToBitField() ||
4190                               Initializer->refersToVectorElement();
4191 
4192   if (IsNonAddressableType) {
4193     // C++11 [dcl.init.ref]p5: [...] Otherwise, the reference shall be an
4194     // lvalue reference to a non-volatile const type, or the reference shall be
4195     // an rvalue reference.
4196     //
4197     // If not, we can't make a temporary and bind to that. Give up and allow the
4198     // error to be diagnosed later.
4199     if (IsLValueRef && (!T1Quals.hasConst() || T1Quals.hasVolatile())) {
4200       assert(Initializer->isGLValue());
4201       return Initializer->getValueKind();
4202     }
4203 
4204     // Force a load so we can materialize a temporary.
4205     Sequence.AddLValueToRValueStep(cv1T1.getUnqualifiedType());
4206     return VK_RValue;
4207   }
4208 
4209   if (T1Quals != T2Quals) {
4210     Sequence.AddQualificationConversionStep(cv1T1,
4211                                             Initializer->getValueKind());
4212   }
4213 
4214   return Initializer->getValueKind();
4215 }
4216 
4217 /// \brief Reference initialization without resolving overloaded functions.
4218 static void TryReferenceInitializationCore(Sema &S,
4219                                            const InitializedEntity &Entity,
4220                                            const InitializationKind &Kind,
4221                                            Expr *Initializer,
4222                                            QualType cv1T1, QualType T1,
4223                                            Qualifiers T1Quals,
4224                                            QualType cv2T2, QualType T2,
4225                                            Qualifiers T2Quals,
4226                                            InitializationSequence &Sequence) {
4227   QualType DestType = Entity.getType();
4228   SourceLocation DeclLoc = Initializer->getLocStart();
4229   // Compute some basic properties of the types and the initializer.
4230   bool isLValueRef = DestType->isLValueReferenceType();
4231   bool isRValueRef = !isLValueRef;
4232   bool DerivedToBase = false;
4233   bool ObjCConversion = false;
4234   bool ObjCLifetimeConversion = false;
4235   Expr::Classification InitCategory = Initializer->Classify(S.Context);
4236   Sema::ReferenceCompareResult RefRelationship
4237     = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
4238                                      ObjCConversion, ObjCLifetimeConversion);
4239 
4240   // C++0x [dcl.init.ref]p5:
4241   //   A reference to type "cv1 T1" is initialized by an expression of type
4242   //   "cv2 T2" as follows:
4243   //
4244   //     - If the reference is an lvalue reference and the initializer
4245   //       expression
4246   // Note the analogous bullet points for rvalue refs to functions. Because
4247   // there are no function rvalues in C++, rvalue refs to functions are treated
4248   // like lvalue refs.
4249   OverloadingResult ConvOvlResult = OR_Success;
4250   bool T1Function = T1->isFunctionType();
4251   if (isLValueRef || T1Function) {
4252     if (InitCategory.isLValue() &&
4253         (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
4254          (Kind.isCStyleOrFunctionalCast() &&
4255           RefRelationship == Sema::Ref_Related))) {
4256       //   - is an lvalue (but is not a bit-field), and "cv1 T1" is
4257       //     reference-compatible with "cv2 T2," or
4258       //
4259       // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a
4260       // bit-field when we're determining whether the reference initialization
4261       // can occur. However, we do pay attention to whether it is a bit-field
4262       // to decide whether we're actually binding to a temporary created from
4263       // the bit-field.
4264       if (DerivedToBase)
4265         Sequence.AddDerivedToBaseCastStep(
4266                          S.Context.getQualifiedType(T1, T2Quals),
4267                          VK_LValue);
4268       else if (ObjCConversion)
4269         Sequence.AddObjCObjectConversionStep(
4270                                      S.Context.getQualifiedType(T1, T2Quals));
4271 
4272       ExprValueKind ValueKind =
4273         convertQualifiersAndValueKindIfNecessary(S, Sequence, Initializer,
4274                                                  cv1T1, T1Quals, T2Quals,
4275                                                  isLValueRef);
4276       Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
4277       return;
4278     }
4279 
4280     //     - has a class type (i.e., T2 is a class type), where T1 is not
4281     //       reference-related to T2, and can be implicitly converted to an
4282     //       lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
4283     //       with "cv3 T3" (this conversion is selected by enumerating the
4284     //       applicable conversion functions (13.3.1.6) and choosing the best
4285     //       one through overload resolution (13.3)),
4286     // If we have an rvalue ref to function type here, the rhs must be
4287     // an rvalue. DR1287 removed the "implicitly" here.
4288     if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
4289         (isLValueRef || InitCategory.isRValue())) {
4290       ConvOvlResult = TryRefInitWithConversionFunction(
4291           S, Entity, Kind, Initializer, /*AllowRValues*/isRValueRef, Sequence);
4292       if (ConvOvlResult == OR_Success)
4293         return;
4294       if (ConvOvlResult != OR_No_Viable_Function)
4295         Sequence.SetOverloadFailure(
4296             InitializationSequence::FK_ReferenceInitOverloadFailed,
4297             ConvOvlResult);
4298     }
4299   }
4300 
4301   //     - Otherwise, the reference shall be an lvalue reference to a
4302   //       non-volatile const type (i.e., cv1 shall be const), or the reference
4303   //       shall be an rvalue reference.
4304   if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
4305     if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4306       Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
4307     else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4308       Sequence.SetOverloadFailure(
4309                         InitializationSequence::FK_ReferenceInitOverloadFailed,
4310                                   ConvOvlResult);
4311     else
4312       Sequence.SetFailed(InitCategory.isLValue()
4313         ? (RefRelationship == Sema::Ref_Related
4314              ? InitializationSequence::FK_ReferenceInitDropsQualifiers
4315              : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated)
4316         : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
4317 
4318     return;
4319   }
4320 
4321   //    - If the initializer expression
4322   //      - is an xvalue, class prvalue, array prvalue, or function lvalue and
4323   //        "cv1 T1" is reference-compatible with "cv2 T2"
4324   // Note: functions are handled below.
4325   if (!T1Function &&
4326       (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
4327        (Kind.isCStyleOrFunctionalCast() &&
4328         RefRelationship == Sema::Ref_Related)) &&
4329       (InitCategory.isXValue() ||
4330        (InitCategory.isPRValue() && T2->isRecordType()) ||
4331        (InitCategory.isPRValue() && T2->isArrayType()))) {
4332     ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue;
4333     if (InitCategory.isPRValue() && T2->isRecordType()) {
4334       // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
4335       // compiler the freedom to perform a copy here or bind to the
4336       // object, while C++0x requires that we bind directly to the
4337       // object. Hence, we always bind to the object without making an
4338       // extra copy. However, in C++03 requires that we check for the
4339       // presence of a suitable copy constructor:
4340       //
4341       //   The constructor that would be used to make the copy shall
4342       //   be callable whether or not the copy is actually done.
4343       if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
4344         Sequence.AddExtraneousCopyToTemporary(cv2T2);
4345       else if (S.getLangOpts().CPlusPlus11)
4346         CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
4347     }
4348 
4349     if (DerivedToBase)
4350       Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals),
4351                                         ValueKind);
4352     else if (ObjCConversion)
4353       Sequence.AddObjCObjectConversionStep(
4354                                        S.Context.getQualifiedType(T1, T2Quals));
4355 
4356     ValueKind = convertQualifiersAndValueKindIfNecessary(S, Sequence,
4357                                                          Initializer, cv1T1,
4358                                                          T1Quals, T2Quals,
4359                                                          isLValueRef);
4360 
4361     Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
4362     return;
4363   }
4364 
4365   //       - has a class type (i.e., T2 is a class type), where T1 is not
4366   //         reference-related to T2, and can be implicitly converted to an
4367   //         xvalue, class prvalue, or function lvalue of type "cv3 T3",
4368   //         where "cv1 T1" is reference-compatible with "cv3 T3",
4369   //
4370   // DR1287 removes the "implicitly" here.
4371   if (T2->isRecordType()) {
4372     if (RefRelationship == Sema::Ref_Incompatible) {
4373       ConvOvlResult = TryRefInitWithConversionFunction(
4374           S, Entity, Kind, Initializer, /*AllowRValues*/true, Sequence);
4375       if (ConvOvlResult)
4376         Sequence.SetOverloadFailure(
4377             InitializationSequence::FK_ReferenceInitOverloadFailed,
4378             ConvOvlResult);
4379 
4380       return;
4381     }
4382 
4383     if ((RefRelationship == Sema::Ref_Compatible ||
4384          RefRelationship == Sema::Ref_Compatible_With_Added_Qualification) &&
4385         isRValueRef && InitCategory.isLValue()) {
4386       Sequence.SetFailed(
4387         InitializationSequence::FK_RValueReferenceBindingToLValue);
4388       return;
4389     }
4390 
4391     Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
4392     return;
4393   }
4394 
4395   //      - Otherwise, a temporary of type "cv1 T1" is created and initialized
4396   //        from the initializer expression using the rules for a non-reference
4397   //        copy-initialization (8.5). The reference is then bound to the
4398   //        temporary. [...]
4399 
4400   InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
4401 
4402   // FIXME: Why do we use an implicit conversion here rather than trying
4403   // copy-initialization?
4404   ImplicitConversionSequence ICS
4405     = S.TryImplicitConversion(Initializer, TempEntity.getType(),
4406                               /*SuppressUserConversions=*/false,
4407                               /*AllowExplicit=*/false,
4408                               /*FIXME:InOverloadResolution=*/false,
4409                               /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4410                               /*AllowObjCWritebackConversion=*/false);
4411 
4412   if (ICS.isBad()) {
4413     // FIXME: Use the conversion function set stored in ICS to turn
4414     // this into an overloading ambiguity diagnostic. However, we need
4415     // to keep that set as an OverloadCandidateSet rather than as some
4416     // other kind of set.
4417     if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4418       Sequence.SetOverloadFailure(
4419                         InitializationSequence::FK_ReferenceInitOverloadFailed,
4420                                   ConvOvlResult);
4421     else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4422       Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
4423     else
4424       Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed);
4425     return;
4426   } else {
4427     Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
4428   }
4429 
4430   //        [...] If T1 is reference-related to T2, cv1 must be the
4431   //        same cv-qualification as, or greater cv-qualification
4432   //        than, cv2; otherwise, the program is ill-formed.
4433   unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
4434   unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
4435   if (RefRelationship == Sema::Ref_Related &&
4436       (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
4437     Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
4438     return;
4439   }
4440 
4441   //   [...] If T1 is reference-related to T2 and the reference is an rvalue
4442   //   reference, the initializer expression shall not be an lvalue.
4443   if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
4444       InitCategory.isLValue()) {
4445     Sequence.SetFailed(
4446                     InitializationSequence::FK_RValueReferenceBindingToLValue);
4447     return;
4448   }
4449 
4450   Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
4451 }
4452 
4453 /// \brief Attempt character array initialization from a string literal
4454 /// (C++ [dcl.init.string], C99 6.7.8).
4455 static void TryStringLiteralInitialization(Sema &S,
4456                                            const InitializedEntity &Entity,
4457                                            const InitializationKind &Kind,
4458                                            Expr *Initializer,
4459                                        InitializationSequence &Sequence) {
4460   Sequence.AddStringInitStep(Entity.getType());
4461 }
4462 
4463 /// \brief Attempt value initialization (C++ [dcl.init]p7).
4464 static void TryValueInitialization(Sema &S,
4465                                    const InitializedEntity &Entity,
4466                                    const InitializationKind &Kind,
4467                                    InitializationSequence &Sequence,
4468                                    InitListExpr *InitList) {
4469   assert((!InitList || InitList->getNumInits() == 0) &&
4470          "Shouldn't use value-init for non-empty init lists");
4471 
4472   // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
4473   //
4474   //   To value-initialize an object of type T means:
4475   QualType T = Entity.getType();
4476 
4477   //     -- if T is an array type, then each element is value-initialized;
4478   T = S.Context.getBaseElementType(T);
4479 
4480   if (const RecordType *RT = T->getAs<RecordType>()) {
4481     if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
4482       bool NeedZeroInitialization = true;
4483       if (!S.getLangOpts().CPlusPlus11) {
4484         // C++98:
4485         // -- if T is a class type (clause 9) with a user-declared constructor
4486         //    (12.1), then the default constructor for T is called (and the
4487         //    initialization is ill-formed if T has no accessible default
4488         //    constructor);
4489         if (ClassDecl->hasUserDeclaredConstructor())
4490           NeedZeroInitialization = false;
4491       } else {
4492         // C++11:
4493         // -- if T is a class type (clause 9) with either no default constructor
4494         //    (12.1 [class.ctor]) or a default constructor that is user-provided
4495         //    or deleted, then the object is default-initialized;
4496         CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
4497         if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
4498           NeedZeroInitialization = false;
4499       }
4500 
4501       // -- if T is a (possibly cv-qualified) non-union class type without a
4502       //    user-provided or deleted default constructor, then the object is
4503       //    zero-initialized and, if T has a non-trivial default constructor,
4504       //    default-initialized;
4505       // The 'non-union' here was removed by DR1502. The 'non-trivial default
4506       // constructor' part was removed by DR1507.
4507       if (NeedZeroInitialization)
4508         Sequence.AddZeroInitializationStep(Entity.getType());
4509 
4510       // C++03:
4511       // -- if T is a non-union class type without a user-declared constructor,
4512       //    then every non-static data member and base class component of T is
4513       //    value-initialized;
4514       // [...] A program that calls for [...] value-initialization of an
4515       // entity of reference type is ill-formed.
4516       //
4517       // C++11 doesn't need this handling, because value-initialization does not
4518       // occur recursively there, and the implicit default constructor is
4519       // defined as deleted in the problematic cases.
4520       if (!S.getLangOpts().CPlusPlus11 &&
4521           ClassDecl->hasUninitializedReferenceMember()) {
4522         Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForReference);
4523         return;
4524       }
4525 
4526       // If this is list-value-initialization, pass the empty init list on when
4527       // building the constructor call. This affects the semantics of a few
4528       // things (such as whether an explicit default constructor can be called).
4529       Expr *InitListAsExpr = InitList;
4530       MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
4531       bool InitListSyntax = InitList;
4532 
4533       return TryConstructorInitialization(S, Entity, Kind, Args, T, Sequence,
4534                                           InitListSyntax);
4535     }
4536   }
4537 
4538   Sequence.AddZeroInitializationStep(Entity.getType());
4539 }
4540 
4541 /// \brief Attempt default initialization (C++ [dcl.init]p6).
4542 static void TryDefaultInitialization(Sema &S,
4543                                      const InitializedEntity &Entity,
4544                                      const InitializationKind &Kind,
4545                                      InitializationSequence &Sequence) {
4546   assert(Kind.getKind() == InitializationKind::IK_Default);
4547 
4548   // C++ [dcl.init]p6:
4549   //   To default-initialize an object of type T means:
4550   //     - if T is an array type, each element is default-initialized;
4551   QualType DestType = S.Context.getBaseElementType(Entity.getType());
4552 
4553   //     - if T is a (possibly cv-qualified) class type (Clause 9), the default
4554   //       constructor for T is called (and the initialization is ill-formed if
4555   //       T has no accessible default constructor);
4556   if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
4557     TryConstructorInitialization(S, Entity, Kind, None, DestType, Sequence);
4558     return;
4559   }
4560 
4561   //     - otherwise, no initialization is performed.
4562 
4563   //   If a program calls for the default initialization of an object of
4564   //   a const-qualified type T, T shall be a class type with a user-provided
4565   //   default constructor.
4566   if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
4567     if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
4568       Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
4569     return;
4570   }
4571 
4572   // If the destination type has a lifetime property, zero-initialize it.
4573   if (DestType.getQualifiers().hasObjCLifetime()) {
4574     Sequence.AddZeroInitializationStep(Entity.getType());
4575     return;
4576   }
4577 }
4578 
4579 /// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
4580 /// which enumerates all conversion functions and performs overload resolution
4581 /// to select the best.
4582 static void TryUserDefinedConversion(Sema &S,
4583                                      QualType DestType,
4584                                      const InitializationKind &Kind,
4585                                      Expr *Initializer,
4586                                      InitializationSequence &Sequence,
4587                                      bool TopLevelOfInitList) {
4588   assert(!DestType->isReferenceType() && "References are handled elsewhere");
4589   QualType SourceType = Initializer->getType();
4590   assert((DestType->isRecordType() || SourceType->isRecordType()) &&
4591          "Must have a class type to perform a user-defined conversion");
4592 
4593   // Build the candidate set directly in the initialization sequence
4594   // structure, so that it will persist if we fail.
4595   OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4596   CandidateSet.clear();
4597 
4598   // Determine whether we are allowed to call explicit constructors or
4599   // explicit conversion operators.
4600   bool AllowExplicit = Kind.AllowExplicit();
4601 
4602   if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4603     // The type we're converting to is a class type. Enumerate its constructors
4604     // to see if there is a suitable conversion.
4605     CXXRecordDecl *DestRecordDecl
4606       = cast<CXXRecordDecl>(DestRecordType->getDecl());
4607 
4608     // Try to complete the type we're converting to.
4609     if (S.isCompleteType(Kind.getLocation(), DestType)) {
4610       DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
4611       // The container holding the constructors can under certain conditions
4612       // be changed while iterating. To be safe we copy the lookup results
4613       // to a new container.
4614       SmallVector<NamedDecl*, 8> CopyOfCon(R.begin(), R.end());
4615       for (SmallVectorImpl<NamedDecl *>::iterator
4616              Con = CopyOfCon.begin(), ConEnd = CopyOfCon.end();
4617            Con != ConEnd; ++Con) {
4618         NamedDecl *D = *Con;
4619         auto Info = getConstructorInfo(D);
4620         if (!Info.Constructor)
4621           continue;
4622 
4623         if (!Info.Constructor->isInvalidDecl() &&
4624             Info.Constructor->isConvertingConstructor(AllowExplicit)) {
4625           if (Info.ConstructorTmpl)
4626             S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
4627                                            /*ExplicitArgs*/ nullptr,
4628                                            Initializer, CandidateSet,
4629                                            /*SuppressUserConversions=*/true);
4630           else
4631             S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
4632                                    Initializer, CandidateSet,
4633                                    /*SuppressUserConversions=*/true);
4634         }
4635       }
4636     }
4637   }
4638 
4639   SourceLocation DeclLoc = Initializer->getLocStart();
4640 
4641   if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
4642     // The type we're converting from is a class type, enumerate its conversion
4643     // functions.
4644 
4645     // We can only enumerate the conversion functions for a complete type; if
4646     // the type isn't complete, simply skip this step.
4647     if (S.isCompleteType(DeclLoc, SourceType)) {
4648       CXXRecordDecl *SourceRecordDecl
4649         = cast<CXXRecordDecl>(SourceRecordType->getDecl());
4650 
4651       const auto &Conversions =
4652           SourceRecordDecl->getVisibleConversionFunctions();
4653       for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4654         NamedDecl *D = *I;
4655         CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4656         if (isa<UsingShadowDecl>(D))
4657           D = cast<UsingShadowDecl>(D)->getTargetDecl();
4658 
4659         FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4660         CXXConversionDecl *Conv;
4661         if (ConvTemplate)
4662           Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4663         else
4664           Conv = cast<CXXConversionDecl>(D);
4665 
4666         if (AllowExplicit || !Conv->isExplicit()) {
4667           if (ConvTemplate)
4668             S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4669                                              ActingDC, Initializer, DestType,
4670                                              CandidateSet, AllowExplicit);
4671           else
4672             S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4673                                      Initializer, DestType, CandidateSet,
4674                                      AllowExplicit);
4675         }
4676       }
4677     }
4678   }
4679 
4680   // Perform overload resolution. If it fails, return the failed result.
4681   OverloadCandidateSet::iterator Best;
4682   if (OverloadingResult Result
4683         = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
4684     Sequence.SetOverloadFailure(
4685                         InitializationSequence::FK_UserConversionOverloadFailed,
4686                                 Result);
4687     return;
4688   }
4689 
4690   FunctionDecl *Function = Best->Function;
4691   Function->setReferenced();
4692   bool HadMultipleCandidates = (CandidateSet.size() > 1);
4693 
4694   if (isa<CXXConstructorDecl>(Function)) {
4695     // Add the user-defined conversion step. Any cv-qualification conversion is
4696     // subsumed by the initialization. Per DR5, the created temporary is of the
4697     // cv-unqualified type of the destination.
4698     Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4699                                    DestType.getUnqualifiedType(),
4700                                    HadMultipleCandidates);
4701     return;
4702   }
4703 
4704   // Add the user-defined conversion step that calls the conversion function.
4705   QualType ConvType = Function->getCallResultType();
4706   if (ConvType->getAs<RecordType>()) {
4707     // If we're converting to a class type, there may be an copy of
4708     // the resulting temporary object (possible to create an object of
4709     // a base class type). That copy is not a separate conversion, so
4710     // we just make a note of the actual destination type (possibly a
4711     // base class of the type returned by the conversion function) and
4712     // let the user-defined conversion step handle the conversion.
4713     Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType,
4714                                    HadMultipleCandidates);
4715     return;
4716   }
4717 
4718   Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
4719                                  HadMultipleCandidates);
4720 
4721   // If the conversion following the call to the conversion function
4722   // is interesting, add it as a separate step.
4723   if (Best->FinalConversion.First || Best->FinalConversion.Second ||
4724       Best->FinalConversion.Third) {
4725     ImplicitConversionSequence ICS;
4726     ICS.setStandard();
4727     ICS.Standard = Best->FinalConversion;
4728     Sequence.AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
4729   }
4730 }
4731 
4732 /// An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>,
4733 /// a function with a pointer return type contains a 'return false;' statement.
4734 /// In C++11, 'false' is not a null pointer, so this breaks the build of any
4735 /// code using that header.
4736 ///
4737 /// Work around this by treating 'return false;' as zero-initializing the result
4738 /// if it's used in a pointer-returning function in a system header.
4739 static bool isLibstdcxxPointerReturnFalseHack(Sema &S,
4740                                               const InitializedEntity &Entity,
4741                                               const Expr *Init) {
4742   return S.getLangOpts().CPlusPlus11 &&
4743          Entity.getKind() == InitializedEntity::EK_Result &&
4744          Entity.getType()->isPointerType() &&
4745          isa<CXXBoolLiteralExpr>(Init) &&
4746          !cast<CXXBoolLiteralExpr>(Init)->getValue() &&
4747          S.getSourceManager().isInSystemHeader(Init->getExprLoc());
4748 }
4749 
4750 /// The non-zero enum values here are indexes into diagnostic alternatives.
4751 enum InvalidICRKind { IIK_okay, IIK_nonlocal, IIK_nonscalar };
4752 
4753 /// Determines whether this expression is an acceptable ICR source.
4754 static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e,
4755                                          bool isAddressOf, bool &isWeakAccess) {
4756   // Skip parens.
4757   e = e->IgnoreParens();
4758 
4759   // Skip address-of nodes.
4760   if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
4761     if (op->getOpcode() == UO_AddrOf)
4762       return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
4763                                 isWeakAccess);
4764 
4765   // Skip certain casts.
4766   } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
4767     switch (ce->getCastKind()) {
4768     case CK_Dependent:
4769     case CK_BitCast:
4770     case CK_LValueBitCast:
4771     case CK_NoOp:
4772       return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
4773 
4774     case CK_ArrayToPointerDecay:
4775       return IIK_nonscalar;
4776 
4777     case CK_NullToPointer:
4778       return IIK_okay;
4779 
4780     default:
4781       break;
4782     }
4783 
4784   // If we have a declaration reference, it had better be a local variable.
4785   } else if (isa<DeclRefExpr>(e)) {
4786     // set isWeakAccess to true, to mean that there will be an implicit
4787     // load which requires a cleanup.
4788     if (e->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
4789       isWeakAccess = true;
4790 
4791     if (!isAddressOf) return IIK_nonlocal;
4792 
4793     VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
4794     if (!var) return IIK_nonlocal;
4795 
4796     return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
4797 
4798   // If we have a conditional operator, check both sides.
4799   } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
4800     if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
4801                                                 isWeakAccess))
4802       return iik;
4803 
4804     return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
4805 
4806   // These are never scalar.
4807   } else if (isa<ArraySubscriptExpr>(e)) {
4808     return IIK_nonscalar;
4809 
4810   // Otherwise, it needs to be a null pointer constant.
4811   } else {
4812     return (e->isNullPointerConstant(C, Expr::NPC_ValueDependentIsNull)
4813             ? IIK_okay : IIK_nonlocal);
4814   }
4815 
4816   return IIK_nonlocal;
4817 }
4818 
4819 /// Check whether the given expression is a valid operand for an
4820 /// indirect copy/restore.
4821 static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {
4822   assert(src->isRValue());
4823   bool isWeakAccess = false;
4824   InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
4825   // If isWeakAccess to true, there will be an implicit
4826   // load which requires a cleanup.
4827   if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
4828     S.Cleanup.setExprNeedsCleanups(true);
4829 
4830   if (iik == IIK_okay) return;
4831 
4832   S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
4833     << ((unsigned) iik - 1)  // shift index into diagnostic explanations
4834     << src->getSourceRange();
4835 }
4836 
4837 /// \brief Determine whether we have compatible array types for the
4838 /// purposes of GNU by-copy array initialization.
4839 static bool hasCompatibleArrayTypes(ASTContext &Context, const ArrayType *Dest,
4840                                     const ArrayType *Source) {
4841   // If the source and destination array types are equivalent, we're
4842   // done.
4843   if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
4844     return true;
4845 
4846   // Make sure that the element types are the same.
4847   if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
4848     return false;
4849 
4850   // The only mismatch we allow is when the destination is an
4851   // incomplete array type and the source is a constant array type.
4852   return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
4853 }
4854 
4855 static bool tryObjCWritebackConversion(Sema &S,
4856                                        InitializationSequence &Sequence,
4857                                        const InitializedEntity &Entity,
4858                                        Expr *Initializer) {
4859   bool ArrayDecay = false;
4860   QualType ArgType = Initializer->getType();
4861   QualType ArgPointee;
4862   if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
4863     ArrayDecay = true;
4864     ArgPointee = ArgArrayType->getElementType();
4865     ArgType = S.Context.getPointerType(ArgPointee);
4866   }
4867 
4868   // Handle write-back conversion.
4869   QualType ConvertedArgType;
4870   if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
4871                                    ConvertedArgType))
4872     return false;
4873 
4874   // We should copy unless we're passing to an argument explicitly
4875   // marked 'out'.
4876   bool ShouldCopy = true;
4877   if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4878     ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4879 
4880   // Do we need an lvalue conversion?
4881   if (ArrayDecay || Initializer->isGLValue()) {
4882     ImplicitConversionSequence ICS;
4883     ICS.setStandard();
4884     ICS.Standard.setAsIdentityConversion();
4885 
4886     QualType ResultType;
4887     if (ArrayDecay) {
4888       ICS.Standard.First = ICK_Array_To_Pointer;
4889       ResultType = S.Context.getPointerType(ArgPointee);
4890     } else {
4891       ICS.Standard.First = ICK_Lvalue_To_Rvalue;
4892       ResultType = Initializer->getType().getNonLValueExprType(S.Context);
4893     }
4894 
4895     Sequence.AddConversionSequenceStep(ICS, ResultType);
4896   }
4897 
4898   Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
4899   return true;
4900 }
4901 
4902 static bool TryOCLSamplerInitialization(Sema &S,
4903                                         InitializationSequence &Sequence,
4904                                         QualType DestType,
4905                                         Expr *Initializer) {
4906   if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
4907       (!Initializer->isIntegerConstantExpr(S.Context) &&
4908       !Initializer->getType()->isSamplerT()))
4909     return false;
4910 
4911   Sequence.AddOCLSamplerInitStep(DestType);
4912   return true;
4913 }
4914 
4915 //
4916 // OpenCL 1.2 spec, s6.12.10
4917 //
4918 // The event argument can also be used to associate the
4919 // async_work_group_copy with a previous async copy allowing
4920 // an event to be shared by multiple async copies; otherwise
4921 // event should be zero.
4922 //
4923 static bool TryOCLZeroEventInitialization(Sema &S,
4924                                           InitializationSequence &Sequence,
4925                                           QualType DestType,
4926                                           Expr *Initializer) {
4927   if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
4928       !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
4929       (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
4930     return false;
4931 
4932   Sequence.AddOCLZeroEventStep(DestType);
4933   return true;
4934 }
4935 
4936 InitializationSequence::InitializationSequence(Sema &S,
4937                                                const InitializedEntity &Entity,
4938                                                const InitializationKind &Kind,
4939                                                MultiExprArg Args,
4940                                                bool TopLevelOfInitList,
4941                                                bool TreatUnavailableAsInvalid)
4942     : FailedCandidateSet(Kind.getLocation(), OverloadCandidateSet::CSK_Normal) {
4943   InitializeFrom(S, Entity, Kind, Args, TopLevelOfInitList,
4944                  TreatUnavailableAsInvalid);
4945 }
4946 
4947 /// Tries to get a FunctionDecl out of `E`. If it succeeds and we can take the
4948 /// address of that function, this returns true. Otherwise, it returns false.
4949 static bool isExprAnUnaddressableFunction(Sema &S, const Expr *E) {
4950   auto *DRE = dyn_cast<DeclRefExpr>(E);
4951   if (!DRE || !isa<FunctionDecl>(DRE->getDecl()))
4952     return false;
4953 
4954   return !S.checkAddressOfFunctionIsAvailable(
4955       cast<FunctionDecl>(DRE->getDecl()));
4956 }
4957 
4958 void InitializationSequence::InitializeFrom(Sema &S,
4959                                             const InitializedEntity &Entity,
4960                                             const InitializationKind &Kind,
4961                                             MultiExprArg Args,
4962                                             bool TopLevelOfInitList,
4963                                             bool TreatUnavailableAsInvalid) {
4964   ASTContext &Context = S.Context;
4965 
4966   // Eliminate non-overload placeholder types in the arguments.  We
4967   // need to do this before checking whether types are dependent
4968   // because lowering a pseudo-object expression might well give us
4969   // something of dependent type.
4970   for (unsigned I = 0, E = Args.size(); I != E; ++I)
4971     if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
4972       // FIXME: should we be doing this here?
4973       ExprResult result = S.CheckPlaceholderExpr(Args[I]);
4974       if (result.isInvalid()) {
4975         SetFailed(FK_PlaceholderType);
4976         return;
4977       }
4978       Args[I] = result.get();
4979     }
4980 
4981   // C++0x [dcl.init]p16:
4982   //   The semantics of initializers are as follows. The destination type is
4983   //   the type of the object or reference being initialized and the source
4984   //   type is the type of the initializer expression. The source type is not
4985   //   defined when the initializer is a braced-init-list or when it is a
4986   //   parenthesized list of expressions.
4987   QualType DestType = Entity.getType();
4988 
4989   if (DestType->isDependentType() ||
4990       Expr::hasAnyTypeDependentArguments(Args)) {
4991     SequenceKind = DependentSequence;
4992     return;
4993   }
4994 
4995   // Almost everything is a normal sequence.
4996   setSequenceKind(NormalSequence);
4997 
4998   QualType SourceType;
4999   Expr *Initializer = nullptr;
5000   if (Args.size() == 1) {
5001     Initializer = Args[0];
5002     if (S.getLangOpts().ObjC1) {
5003       if (S.CheckObjCBridgeRelatedConversions(Initializer->getLocStart(),
5004                                               DestType, Initializer->getType(),
5005                                               Initializer) ||
5006           S.ConversionToObjCStringLiteralCheck(DestType, Initializer))
5007         Args[0] = Initializer;
5008     }
5009     if (!isa<InitListExpr>(Initializer))
5010       SourceType = Initializer->getType();
5011   }
5012 
5013   //     - If the initializer is a (non-parenthesized) braced-init-list, the
5014   //       object is list-initialized (8.5.4).
5015   if (Kind.getKind() != InitializationKind::IK_Direct) {
5016     if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
5017       TryListInitialization(S, Entity, Kind, InitList, *this,
5018                             TreatUnavailableAsInvalid);
5019       return;
5020     }
5021   }
5022 
5023   //     - If the destination type is a reference type, see 8.5.3.
5024   if (DestType->isReferenceType()) {
5025     // C++0x [dcl.init.ref]p1:
5026     //   A variable declared to be a T& or T&&, that is, "reference to type T"
5027     //   (8.3.2), shall be initialized by an object, or function, of type T or
5028     //   by an object that can be converted into a T.
5029     // (Therefore, multiple arguments are not permitted.)
5030     if (Args.size() != 1)
5031       SetFailed(FK_TooManyInitsForReference);
5032     else
5033       TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
5034     return;
5035   }
5036 
5037   //     - If the initializer is (), the object is value-initialized.
5038   if (Kind.getKind() == InitializationKind::IK_Value ||
5039       (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
5040     TryValueInitialization(S, Entity, Kind, *this);
5041     return;
5042   }
5043 
5044   // Handle default initialization.
5045   if (Kind.getKind() == InitializationKind::IK_Default) {
5046     TryDefaultInitialization(S, Entity, Kind, *this);
5047     return;
5048   }
5049 
5050   //     - If the destination type is an array of characters, an array of
5051   //       char16_t, an array of char32_t, or an array of wchar_t, and the
5052   //       initializer is a string literal, see 8.5.2.
5053   //     - Otherwise, if the destination type is an array, the program is
5054   //       ill-formed.
5055   if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
5056     if (Initializer && isa<VariableArrayType>(DestAT)) {
5057       SetFailed(FK_VariableLengthArrayHasInitializer);
5058       return;
5059     }
5060 
5061     if (Initializer) {
5062       switch (IsStringInit(Initializer, DestAT, Context)) {
5063       case SIF_None:
5064         TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
5065         return;
5066       case SIF_NarrowStringIntoWideChar:
5067         SetFailed(FK_NarrowStringIntoWideCharArray);
5068         return;
5069       case SIF_WideStringIntoChar:
5070         SetFailed(FK_WideStringIntoCharArray);
5071         return;
5072       case SIF_IncompatWideStringIntoWideChar:
5073         SetFailed(FK_IncompatWideStringIntoWideChar);
5074         return;
5075       case SIF_Other:
5076         break;
5077       }
5078     }
5079 
5080     // Note: as an GNU C extension, we allow initialization of an
5081     // array from a compound literal that creates an array of the same
5082     // type, so long as the initializer has no side effects.
5083     if (!S.getLangOpts().CPlusPlus && Initializer &&
5084         isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
5085         Initializer->getType()->isArrayType()) {
5086       const ArrayType *SourceAT
5087         = Context.getAsArrayType(Initializer->getType());
5088       if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
5089         SetFailed(FK_ArrayTypeMismatch);
5090       else if (Initializer->HasSideEffects(S.Context))
5091         SetFailed(FK_NonConstantArrayInit);
5092       else {
5093         AddArrayInitStep(DestType);
5094       }
5095     }
5096     // Note: as a GNU C++ extension, we allow list-initialization of a
5097     // class member of array type from a parenthesized initializer list.
5098     else if (S.getLangOpts().CPlusPlus &&
5099              Entity.getKind() == InitializedEntity::EK_Member &&
5100              Initializer && isa<InitListExpr>(Initializer)) {
5101       TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
5102                             *this, TreatUnavailableAsInvalid);
5103       AddParenthesizedArrayInitStep(DestType);
5104     } else if (DestAT->getElementType()->isCharType())
5105       SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
5106     else if (IsWideCharCompatible(DestAT->getElementType(), Context))
5107       SetFailed(FK_ArrayNeedsInitListOrWideStringLiteral);
5108     else
5109       SetFailed(FK_ArrayNeedsInitList);
5110 
5111     return;
5112   }
5113 
5114   // Determine whether we should consider writeback conversions for
5115   // Objective-C ARC.
5116   bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
5117          Entity.isParameterKind();
5118 
5119   // We're at the end of the line for C: it's either a write-back conversion
5120   // or it's a C assignment. There's no need to check anything else.
5121   if (!S.getLangOpts().CPlusPlus) {
5122     // If allowed, check whether this is an Objective-C writeback conversion.
5123     if (allowObjCWritebackConversion &&
5124         tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
5125       return;
5126     }
5127 
5128     if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
5129       return;
5130 
5131     if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
5132       return;
5133 
5134     // Handle initialization in C
5135     AddCAssignmentStep(DestType);
5136     MaybeProduceObjCObject(S, *this, Entity);
5137     return;
5138   }
5139 
5140   assert(S.getLangOpts().CPlusPlus);
5141 
5142   //     - If the destination type is a (possibly cv-qualified) class type:
5143   if (DestType->isRecordType()) {
5144     //     - If the initialization is direct-initialization, or if it is
5145     //       copy-initialization where the cv-unqualified version of the
5146     //       source type is the same class as, or a derived class of, the
5147     //       class of the destination, constructors are considered. [...]
5148     if (Kind.getKind() == InitializationKind::IK_Direct ||
5149         (Kind.getKind() == InitializationKind::IK_Copy &&
5150          (Context.hasSameUnqualifiedType(SourceType, DestType) ||
5151           S.IsDerivedFrom(Initializer->getLocStart(), SourceType, DestType))))
5152       TryConstructorInitialization(S, Entity, Kind, Args,
5153                                    DestType, *this);
5154     //     - Otherwise (i.e., for the remaining copy-initialization cases),
5155     //       user-defined conversion sequences that can convert from the source
5156     //       type to the destination type or (when a conversion function is
5157     //       used) to a derived class thereof are enumerated as described in
5158     //       13.3.1.4, and the best one is chosen through overload resolution
5159     //       (13.3).
5160     else
5161       TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5162                                TopLevelOfInitList);
5163     return;
5164   }
5165 
5166   if (Args.size() > 1) {
5167     SetFailed(FK_TooManyInitsForScalar);
5168     return;
5169   }
5170   assert(Args.size() == 1 && "Zero-argument case handled above");
5171 
5172   //    - Otherwise, if the source type is a (possibly cv-qualified) class
5173   //      type, conversion functions are considered.
5174   if (!SourceType.isNull() && SourceType->isRecordType()) {
5175     // For a conversion to _Atomic(T) from either T or a class type derived
5176     // from T, initialize the T object then convert to _Atomic type.
5177     bool NeedAtomicConversion = false;
5178     if (const AtomicType *Atomic = DestType->getAs<AtomicType>()) {
5179       if (Context.hasSameUnqualifiedType(SourceType, Atomic->getValueType()) ||
5180           S.IsDerivedFrom(Initializer->getLocStart(), SourceType,
5181                           Atomic->getValueType())) {
5182         DestType = Atomic->getValueType();
5183         NeedAtomicConversion = true;
5184       }
5185     }
5186 
5187     TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5188                              TopLevelOfInitList);
5189     MaybeProduceObjCObject(S, *this, Entity);
5190     if (!Failed() && NeedAtomicConversion)
5191       AddAtomicConversionStep(Entity.getType());
5192     return;
5193   }
5194 
5195   //    - Otherwise, the initial value of the object being initialized is the
5196   //      (possibly converted) value of the initializer expression. Standard
5197   //      conversions (Clause 4) will be used, if necessary, to convert the
5198   //      initializer expression to the cv-unqualified version of the
5199   //      destination type; no user-defined conversions are considered.
5200 
5201   ImplicitConversionSequence ICS
5202     = S.TryImplicitConversion(Initializer, DestType,
5203                               /*SuppressUserConversions*/true,
5204                               /*AllowExplicitConversions*/ false,
5205                               /*InOverloadResolution*/ false,
5206                               /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
5207                               allowObjCWritebackConversion);
5208 
5209   if (ICS.isStandard() &&
5210       ICS.Standard.Second == ICK_Writeback_Conversion) {
5211     // Objective-C ARC writeback conversion.
5212 
5213     // We should copy unless we're passing to an argument explicitly
5214     // marked 'out'.
5215     bool ShouldCopy = true;
5216     if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
5217       ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
5218 
5219     // If there was an lvalue adjustment, add it as a separate conversion.
5220     if (ICS.Standard.First == ICK_Array_To_Pointer ||
5221         ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
5222       ImplicitConversionSequence LvalueICS;
5223       LvalueICS.setStandard();
5224       LvalueICS.Standard.setAsIdentityConversion();
5225       LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0));
5226       LvalueICS.Standard.First = ICS.Standard.First;
5227       AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0));
5228     }
5229 
5230     AddPassByIndirectCopyRestoreStep(DestType, ShouldCopy);
5231   } else if (ICS.isBad()) {
5232     DeclAccessPair dap;
5233     if (isLibstdcxxPointerReturnFalseHack(S, Entity, Initializer)) {
5234       AddZeroInitializationStep(Entity.getType());
5235     } else if (Initializer->getType() == Context.OverloadTy &&
5236                !S.ResolveAddressOfOverloadedFunction(Initializer, DestType,
5237                                                      false, dap))
5238       SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
5239     else if (Initializer->getType()->isFunctionType() &&
5240              isExprAnUnaddressableFunction(S, Initializer))
5241       SetFailed(InitializationSequence::FK_AddressOfUnaddressableFunction);
5242     else
5243       SetFailed(InitializationSequence::FK_ConversionFailed);
5244   } else {
5245     AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
5246 
5247     MaybeProduceObjCObject(S, *this, Entity);
5248   }
5249 }
5250 
5251 InitializationSequence::~InitializationSequence() {
5252   for (auto &S : Steps)
5253     S.Destroy();
5254 }
5255 
5256 //===----------------------------------------------------------------------===//
5257 // Perform initialization
5258 //===----------------------------------------------------------------------===//
5259 static Sema::AssignmentAction
5260 getAssignmentAction(const InitializedEntity &Entity, bool Diagnose = false) {
5261   switch(Entity.getKind()) {
5262   case InitializedEntity::EK_Variable:
5263   case InitializedEntity::EK_New:
5264   case InitializedEntity::EK_Exception:
5265   case InitializedEntity::EK_Base:
5266   case InitializedEntity::EK_Delegating:
5267     return Sema::AA_Initializing;
5268 
5269   case InitializedEntity::EK_Parameter:
5270     if (Entity.getDecl() &&
5271         isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
5272       return Sema::AA_Sending;
5273 
5274     return Sema::AA_Passing;
5275 
5276   case InitializedEntity::EK_Parameter_CF_Audited:
5277     if (Entity.getDecl() &&
5278       isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
5279       return Sema::AA_Sending;
5280 
5281     return !Diagnose ? Sema::AA_Passing : Sema::AA_Passing_CFAudited;
5282 
5283   case InitializedEntity::EK_Result:
5284     return Sema::AA_Returning;
5285 
5286   case InitializedEntity::EK_Temporary:
5287   case InitializedEntity::EK_RelatedResult:
5288     // FIXME: Can we tell apart casting vs. converting?
5289     return Sema::AA_Casting;
5290 
5291   case InitializedEntity::EK_Member:
5292   case InitializedEntity::EK_Binding:
5293   case InitializedEntity::EK_ArrayElement:
5294   case InitializedEntity::EK_VectorElement:
5295   case InitializedEntity::EK_ComplexElement:
5296   case InitializedEntity::EK_BlockElement:
5297   case InitializedEntity::EK_LambdaCapture:
5298   case InitializedEntity::EK_CompoundLiteralInit:
5299     return Sema::AA_Initializing;
5300   }
5301 
5302   llvm_unreachable("Invalid EntityKind!");
5303 }
5304 
5305 /// \brief Whether we should bind a created object as a temporary when
5306 /// initializing the given entity.
5307 static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
5308   switch (Entity.getKind()) {
5309   case InitializedEntity::EK_ArrayElement:
5310   case InitializedEntity::EK_Member:
5311   case InitializedEntity::EK_Result:
5312   case InitializedEntity::EK_New:
5313   case InitializedEntity::EK_Variable:
5314   case InitializedEntity::EK_Base:
5315   case InitializedEntity::EK_Delegating:
5316   case InitializedEntity::EK_VectorElement:
5317   case InitializedEntity::EK_ComplexElement:
5318   case InitializedEntity::EK_Exception:
5319   case InitializedEntity::EK_BlockElement:
5320   case InitializedEntity::EK_LambdaCapture:
5321   case InitializedEntity::EK_CompoundLiteralInit:
5322     return false;
5323 
5324   case InitializedEntity::EK_Parameter:
5325   case InitializedEntity::EK_Parameter_CF_Audited:
5326   case InitializedEntity::EK_Temporary:
5327   case InitializedEntity::EK_RelatedResult:
5328   case InitializedEntity::EK_Binding:
5329     return true;
5330   }
5331 
5332   llvm_unreachable("missed an InitializedEntity kind?");
5333 }
5334 
5335 /// \brief Whether the given entity, when initialized with an object
5336 /// created for that initialization, requires destruction.
5337 static bool shouldDestroyTemporary(const InitializedEntity &Entity) {
5338   switch (Entity.getKind()) {
5339     case InitializedEntity::EK_Result:
5340     case InitializedEntity::EK_New:
5341     case InitializedEntity::EK_Base:
5342     case InitializedEntity::EK_Delegating:
5343     case InitializedEntity::EK_VectorElement:
5344     case InitializedEntity::EK_ComplexElement:
5345     case InitializedEntity::EK_BlockElement:
5346     case InitializedEntity::EK_LambdaCapture:
5347       return false;
5348 
5349     case InitializedEntity::EK_Member:
5350     case InitializedEntity::EK_Binding:
5351     case InitializedEntity::EK_Variable:
5352     case InitializedEntity::EK_Parameter:
5353     case InitializedEntity::EK_Parameter_CF_Audited:
5354     case InitializedEntity::EK_Temporary:
5355     case InitializedEntity::EK_ArrayElement:
5356     case InitializedEntity::EK_Exception:
5357     case InitializedEntity::EK_CompoundLiteralInit:
5358     case InitializedEntity::EK_RelatedResult:
5359       return true;
5360   }
5361 
5362   llvm_unreachable("missed an InitializedEntity kind?");
5363 }
5364 
5365 /// \brief Get the location at which initialization diagnostics should appear.
5366 static SourceLocation getInitializationLoc(const InitializedEntity &Entity,
5367                                            Expr *Initializer) {
5368   switch (Entity.getKind()) {
5369   case InitializedEntity::EK_Result:
5370     return Entity.getReturnLoc();
5371 
5372   case InitializedEntity::EK_Exception:
5373     return Entity.getThrowLoc();
5374 
5375   case InitializedEntity::EK_Variable:
5376   case InitializedEntity::EK_Binding:
5377     return Entity.getDecl()->getLocation();
5378 
5379   case InitializedEntity::EK_LambdaCapture:
5380     return Entity.getCaptureLoc();
5381 
5382   case InitializedEntity::EK_ArrayElement:
5383   case InitializedEntity::EK_Member:
5384   case InitializedEntity::EK_Parameter:
5385   case InitializedEntity::EK_Parameter_CF_Audited:
5386   case InitializedEntity::EK_Temporary:
5387   case InitializedEntity::EK_New:
5388   case InitializedEntity::EK_Base:
5389   case InitializedEntity::EK_Delegating:
5390   case InitializedEntity::EK_VectorElement:
5391   case InitializedEntity::EK_ComplexElement:
5392   case InitializedEntity::EK_BlockElement:
5393   case InitializedEntity::EK_CompoundLiteralInit:
5394   case InitializedEntity::EK_RelatedResult:
5395     return Initializer->getLocStart();
5396   }
5397   llvm_unreachable("missed an InitializedEntity kind?");
5398 }
5399 
5400 /// \brief Make a (potentially elidable) temporary copy of the object
5401 /// provided by the given initializer by calling the appropriate copy
5402 /// constructor.
5403 ///
5404 /// \param S The Sema object used for type-checking.
5405 ///
5406 /// \param T The type of the temporary object, which must either be
5407 /// the type of the initializer expression or a superclass thereof.
5408 ///
5409 /// \param Entity The entity being initialized.
5410 ///
5411 /// \param CurInit The initializer expression.
5412 ///
5413 /// \param IsExtraneousCopy Whether this is an "extraneous" copy that
5414 /// is permitted in C++03 (but not C++0x) when binding a reference to
5415 /// an rvalue.
5416 ///
5417 /// \returns An expression that copies the initializer expression into
5418 /// a temporary object, or an error expression if a copy could not be
5419 /// created.
5420 static ExprResult CopyObject(Sema &S,
5421                              QualType T,
5422                              const InitializedEntity &Entity,
5423                              ExprResult CurInit,
5424                              bool IsExtraneousCopy) {
5425   if (CurInit.isInvalid())
5426     return CurInit;
5427   // Determine which class type we're copying to.
5428   Expr *CurInitExpr = (Expr *)CurInit.get();
5429   CXXRecordDecl *Class = nullptr;
5430   if (const RecordType *Record = T->getAs<RecordType>())
5431     Class = cast<CXXRecordDecl>(Record->getDecl());
5432   if (!Class)
5433     return CurInit;
5434 
5435   SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
5436 
5437   // Make sure that the type we are copying is complete.
5438   if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
5439     return CurInit;
5440 
5441   // Perform overload resolution using the class's constructors. Per
5442   // C++11 [dcl.init]p16, second bullet for class types, this initialization
5443   // is direct-initialization.
5444   OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5445   DeclContext::lookup_result Ctors = S.LookupConstructors(Class);
5446 
5447   OverloadCandidateSet::iterator Best;
5448   switch (ResolveConstructorOverload(
5449       S, Loc, CurInitExpr, CandidateSet, Ctors, Best,
5450       /*CopyInitializing=*/false, /*AllowExplicit=*/true,
5451       /*OnlyListConstructors=*/false, /*IsListInit=*/false,
5452       /*SecondStepOfCopyInit=*/true)) {
5453   case OR_Success:
5454     break;
5455 
5456   case OR_No_Viable_Function:
5457     S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
5458            ? diag::ext_rvalue_to_reference_temp_copy_no_viable
5459            : diag::err_temp_copy_no_viable)
5460       << (int)Entity.getKind() << CurInitExpr->getType()
5461       << CurInitExpr->getSourceRange();
5462     CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5463     if (!IsExtraneousCopy || S.isSFINAEContext())
5464       return ExprError();
5465     return CurInit;
5466 
5467   case OR_Ambiguous:
5468     S.Diag(Loc, diag::err_temp_copy_ambiguous)
5469       << (int)Entity.getKind() << CurInitExpr->getType()
5470       << CurInitExpr->getSourceRange();
5471     CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5472     return ExprError();
5473 
5474   case OR_Deleted:
5475     S.Diag(Loc, diag::err_temp_copy_deleted)
5476       << (int)Entity.getKind() << CurInitExpr->getType()
5477       << CurInitExpr->getSourceRange();
5478     S.NoteDeletedFunction(Best->Function);
5479     return ExprError();
5480   }
5481 
5482   bool HadMultipleCandidates = CandidateSet.size() > 1;
5483 
5484   CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
5485   SmallVector<Expr*, 8> ConstructorArgs;
5486   CurInit.get(); // Ownership transferred into MultiExprArg, below.
5487 
5488   S.CheckConstructorAccess(Loc, Constructor, Best->FoundDecl, Entity,
5489                            IsExtraneousCopy);
5490 
5491   if (IsExtraneousCopy) {
5492     // If this is a totally extraneous copy for C++03 reference
5493     // binding purposes, just return the original initialization
5494     // expression. We don't generate an (elided) copy operation here
5495     // because doing so would require us to pass down a flag to avoid
5496     // infinite recursion, where each step adds another extraneous,
5497     // elidable copy.
5498 
5499     // Instantiate the default arguments of any extra parameters in
5500     // the selected copy constructor, as if we were going to create a
5501     // proper call to the copy constructor.
5502     for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
5503       ParmVarDecl *Parm = Constructor->getParamDecl(I);
5504       if (S.RequireCompleteType(Loc, Parm->getType(),
5505                                 diag::err_call_incomplete_argument))
5506         break;
5507 
5508       // Build the default argument expression; we don't actually care
5509       // if this succeeds or not, because this routine will complain
5510       // if there was a problem.
5511       S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
5512     }
5513 
5514     return CurInitExpr;
5515   }
5516 
5517   // Determine the arguments required to actually perform the
5518   // constructor call (we might have derived-to-base conversions, or
5519   // the copy constructor may have default arguments).
5520   if (S.CompleteConstructorCall(Constructor, CurInitExpr, Loc, ConstructorArgs))
5521     return ExprError();
5522 
5523   // C++0x [class.copy]p32:
5524   //   When certain criteria are met, an implementation is allowed to
5525   //   omit the copy/move construction of a class object, even if the
5526   //   copy/move constructor and/or destructor for the object have
5527   //   side effects. [...]
5528   //     - when a temporary class object that has not been bound to a
5529   //       reference (12.2) would be copied/moved to a class object
5530   //       with the same cv-unqualified type, the copy/move operation
5531   //       can be omitted by constructing the temporary object
5532   //       directly into the target of the omitted copy/move
5533   //
5534   // Note that the other three bullets are handled elsewhere. Copy
5535   // elision for return statements and throw expressions are handled as part
5536   // of constructor initialization, while copy elision for exception handlers
5537   // is handled by the run-time.
5538   //
5539   // FIXME: If the function parameter is not the same type as the temporary, we
5540   // should still be able to elide the copy, but we don't have a way to
5541   // represent in the AST how much should be elided in this case.
5542   bool Elidable =
5543       CurInitExpr->isTemporaryObject(S.Context, Class) &&
5544       S.Context.hasSameUnqualifiedType(
5545           Best->Function->getParamDecl(0)->getType().getNonReferenceType(),
5546           CurInitExpr->getType());
5547 
5548   // Actually perform the constructor call.
5549   CurInit = S.BuildCXXConstructExpr(Loc, T, Best->FoundDecl, Constructor,
5550                                     Elidable,
5551                                     ConstructorArgs,
5552                                     HadMultipleCandidates,
5553                                     /*ListInit*/ false,
5554                                     /*StdInitListInit*/ false,
5555                                     /*ZeroInit*/ false,
5556                                     CXXConstructExpr::CK_Complete,
5557                                     SourceRange());
5558 
5559   // If we're supposed to bind temporaries, do so.
5560   if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
5561     CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
5562   return CurInit;
5563 }
5564 
5565 /// \brief Check whether elidable copy construction for binding a reference to
5566 /// a temporary would have succeeded if we were building in C++98 mode, for
5567 /// -Wc++98-compat.
5568 static void CheckCXX98CompatAccessibleCopy(Sema &S,
5569                                            const InitializedEntity &Entity,
5570                                            Expr *CurInitExpr) {
5571   assert(S.getLangOpts().CPlusPlus11);
5572 
5573   const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>();
5574   if (!Record)
5575     return;
5576 
5577   SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr);
5578   if (S.Diags.isIgnored(diag::warn_cxx98_compat_temp_copy, Loc))
5579     return;
5580 
5581   // Find constructors which would have been considered.
5582   OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5583   DeclContext::lookup_result Ctors =
5584       S.LookupConstructors(cast<CXXRecordDecl>(Record->getDecl()));
5585 
5586   // Perform overload resolution.
5587   OverloadCandidateSet::iterator Best;
5588   OverloadingResult OR = ResolveConstructorOverload(
5589       S, Loc, CurInitExpr, CandidateSet, Ctors, Best,
5590       /*CopyInitializing=*/false, /*AllowExplicit=*/true,
5591       /*OnlyListConstructors=*/false, /*IsListInit=*/false,
5592       /*SecondStepOfCopyInit=*/true);
5593 
5594   PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy)
5595     << OR << (int)Entity.getKind() << CurInitExpr->getType()
5596     << CurInitExpr->getSourceRange();
5597 
5598   switch (OR) {
5599   case OR_Success:
5600     S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
5601                              Best->FoundDecl, Entity, Diag);
5602     // FIXME: Check default arguments as far as that's possible.
5603     break;
5604 
5605   case OR_No_Viable_Function:
5606     S.Diag(Loc, Diag);
5607     CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5608     break;
5609 
5610   case OR_Ambiguous:
5611     S.Diag(Loc, Diag);
5612     CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5613     break;
5614 
5615   case OR_Deleted:
5616     S.Diag(Loc, Diag);
5617     S.NoteDeletedFunction(Best->Function);
5618     break;
5619   }
5620 }
5621 
5622 void InitializationSequence::PrintInitLocationNote(Sema &S,
5623                                               const InitializedEntity &Entity) {
5624   if (Entity.isParameterKind() && Entity.getDecl()) {
5625     if (Entity.getDecl()->getLocation().isInvalid())
5626       return;
5627 
5628     if (Entity.getDecl()->getDeclName())
5629       S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
5630         << Entity.getDecl()->getDeclName();
5631     else
5632       S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
5633   }
5634   else if (Entity.getKind() == InitializedEntity::EK_RelatedResult &&
5635            Entity.getMethodDecl())
5636     S.Diag(Entity.getMethodDecl()->getLocation(),
5637            diag::note_method_return_type_change)
5638       << Entity.getMethodDecl()->getDeclName();
5639 }
5640 
5641 static bool isReferenceBinding(const InitializationSequence::Step &s) {
5642   return s.Kind == InitializationSequence::SK_BindReference ||
5643          s.Kind == InitializationSequence::SK_BindReferenceToTemporary;
5644 }
5645 
5646 /// Returns true if the parameters describe a constructor initialization of
5647 /// an explicit temporary object, e.g. "Point(x, y)".
5648 static bool isExplicitTemporary(const InitializedEntity &Entity,
5649                                 const InitializationKind &Kind,
5650                                 unsigned NumArgs) {
5651   switch (Entity.getKind()) {
5652   case InitializedEntity::EK_Temporary:
5653   case InitializedEntity::EK_CompoundLiteralInit:
5654   case InitializedEntity::EK_RelatedResult:
5655     break;
5656   default:
5657     return false;
5658   }
5659 
5660   switch (Kind.getKind()) {
5661   case InitializationKind::IK_DirectList:
5662     return true;
5663   // FIXME: Hack to work around cast weirdness.
5664   case InitializationKind::IK_Direct:
5665   case InitializationKind::IK_Value:
5666     return NumArgs != 1;
5667   default:
5668     return false;
5669   }
5670 }
5671 
5672 static ExprResult
5673 PerformConstructorInitialization(Sema &S,
5674                                  const InitializedEntity &Entity,
5675                                  const InitializationKind &Kind,
5676                                  MultiExprArg Args,
5677                                  const InitializationSequence::Step& Step,
5678                                  bool &ConstructorInitRequiresZeroInit,
5679                                  bool IsListInitialization,
5680                                  bool IsStdInitListInitialization,
5681                                  SourceLocation LBraceLoc,
5682                                  SourceLocation RBraceLoc) {
5683   unsigned NumArgs = Args.size();
5684   CXXConstructorDecl *Constructor
5685     = cast<CXXConstructorDecl>(Step.Function.Function);
5686   bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
5687 
5688   // Build a call to the selected constructor.
5689   SmallVector<Expr*, 8> ConstructorArgs;
5690   SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
5691                          ? Kind.getEqualLoc()
5692                          : Kind.getLocation();
5693 
5694   if (Kind.getKind() == InitializationKind::IK_Default) {
5695     // Force even a trivial, implicit default constructor to be
5696     // semantically checked. We do this explicitly because we don't build
5697     // the definition for completely trivial constructors.
5698     assert(Constructor->getParent() && "No parent class for constructor.");
5699     if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
5700         Constructor->isTrivial() && !Constructor->isUsed(false))
5701       S.DefineImplicitDefaultConstructor(Loc, Constructor);
5702   }
5703 
5704   ExprResult CurInit((Expr *)nullptr);
5705 
5706   // C++ [over.match.copy]p1:
5707   //   - When initializing a temporary to be bound to the first parameter
5708   //     of a constructor that takes a reference to possibly cv-qualified
5709   //     T as its first argument, called with a single argument in the
5710   //     context of direct-initialization, explicit conversion functions
5711   //     are also considered.
5712   bool AllowExplicitConv =
5713       Kind.AllowExplicit() && !Kind.isCopyInit() && Args.size() == 1 &&
5714       hasCopyOrMoveCtorParam(S.Context,
5715                              getConstructorInfo(Step.Function.FoundDecl));
5716 
5717   // Determine the arguments required to actually perform the constructor
5718   // call.
5719   if (S.CompleteConstructorCall(Constructor, Args,
5720                                 Loc, ConstructorArgs,
5721                                 AllowExplicitConv,
5722                                 IsListInitialization))
5723     return ExprError();
5724 
5725 
5726   if (isExplicitTemporary(Entity, Kind, NumArgs)) {
5727     // An explicitly-constructed temporary, e.g., X(1, 2).
5728     if (S.DiagnoseUseOfDecl(Constructor, Loc))
5729       return ExprError();
5730 
5731     TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5732     if (!TSInfo)
5733       TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
5734     SourceRange ParenOrBraceRange =
5735       (Kind.getKind() == InitializationKind::IK_DirectList)
5736       ? SourceRange(LBraceLoc, RBraceLoc)
5737       : Kind.getParenRange();
5738 
5739     if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(
5740             Step.Function.FoundDecl.getDecl())) {
5741       Constructor = S.findInheritingConstructor(Loc, Constructor, Shadow);
5742       if (S.DiagnoseUseOfDecl(Constructor, Loc))
5743         return ExprError();
5744     }
5745     S.MarkFunctionReferenced(Loc, Constructor);
5746 
5747     CurInit = new (S.Context) CXXTemporaryObjectExpr(
5748         S.Context, Constructor, TSInfo,
5749         ConstructorArgs, ParenOrBraceRange, HadMultipleCandidates,
5750         IsListInitialization, IsStdInitListInitialization,
5751         ConstructorInitRequiresZeroInit);
5752   } else {
5753     CXXConstructExpr::ConstructionKind ConstructKind =
5754       CXXConstructExpr::CK_Complete;
5755 
5756     if (Entity.getKind() == InitializedEntity::EK_Base) {
5757       ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
5758         CXXConstructExpr::CK_VirtualBase :
5759         CXXConstructExpr::CK_NonVirtualBase;
5760     } else if (Entity.getKind() == InitializedEntity::EK_Delegating) {
5761       ConstructKind = CXXConstructExpr::CK_Delegating;
5762     }
5763 
5764     // Only get the parenthesis or brace range if it is a list initialization or
5765     // direct construction.
5766     SourceRange ParenOrBraceRange;
5767     if (IsListInitialization)
5768       ParenOrBraceRange = SourceRange(LBraceLoc, RBraceLoc);
5769     else if (Kind.getKind() == InitializationKind::IK_Direct)
5770       ParenOrBraceRange = Kind.getParenRange();
5771 
5772     // If the entity allows NRVO, mark the construction as elidable
5773     // unconditionally.
5774     if (Entity.allowsNRVO())
5775       CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5776                                         Step.Function.FoundDecl,
5777                                         Constructor, /*Elidable=*/true,
5778                                         ConstructorArgs,
5779                                         HadMultipleCandidates,
5780                                         IsListInitialization,
5781                                         IsStdInitListInitialization,
5782                                         ConstructorInitRequiresZeroInit,
5783                                         ConstructKind,
5784                                         ParenOrBraceRange);
5785     else
5786       CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5787                                         Step.Function.FoundDecl,
5788                                         Constructor,
5789                                         ConstructorArgs,
5790                                         HadMultipleCandidates,
5791                                         IsListInitialization,
5792                                         IsStdInitListInitialization,
5793                                         ConstructorInitRequiresZeroInit,
5794                                         ConstructKind,
5795                                         ParenOrBraceRange);
5796   }
5797   if (CurInit.isInvalid())
5798     return ExprError();
5799 
5800   // Only check access if all of that succeeded.
5801   S.CheckConstructorAccess(Loc, Constructor, Step.Function.FoundDecl, Entity);
5802   if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc))
5803     return ExprError();
5804 
5805   if (shouldBindAsTemporary(Entity))
5806     CurInit = S.MaybeBindToTemporary(CurInit.get());
5807 
5808   return CurInit;
5809 }
5810 
5811 /// Determine whether the specified InitializedEntity definitely has a lifetime
5812 /// longer than the current full-expression. Conservatively returns false if
5813 /// it's unclear.
5814 static bool
5815 InitializedEntityOutlivesFullExpression(const InitializedEntity &Entity) {
5816   const InitializedEntity *Top = &Entity;
5817   while (Top->getParent())
5818     Top = Top->getParent();
5819 
5820   switch (Top->getKind()) {
5821   case InitializedEntity::EK_Variable:
5822   case InitializedEntity::EK_Result:
5823   case InitializedEntity::EK_Exception:
5824   case InitializedEntity::EK_Member:
5825   case InitializedEntity::EK_Binding:
5826   case InitializedEntity::EK_New:
5827   case InitializedEntity::EK_Base:
5828   case InitializedEntity::EK_Delegating:
5829     return true;
5830 
5831   case InitializedEntity::EK_ArrayElement:
5832   case InitializedEntity::EK_VectorElement:
5833   case InitializedEntity::EK_BlockElement:
5834   case InitializedEntity::EK_ComplexElement:
5835     // Could not determine what the full initialization is. Assume it might not
5836     // outlive the full-expression.
5837     return false;
5838 
5839   case InitializedEntity::EK_Parameter:
5840   case InitializedEntity::EK_Parameter_CF_Audited:
5841   case InitializedEntity::EK_Temporary:
5842   case InitializedEntity::EK_LambdaCapture:
5843   case InitializedEntity::EK_CompoundLiteralInit:
5844   case InitializedEntity::EK_RelatedResult:
5845     // The entity being initialized might not outlive the full-expression.
5846     return false;
5847   }
5848 
5849   llvm_unreachable("unknown entity kind");
5850 }
5851 
5852 /// Determine the declaration which an initialized entity ultimately refers to,
5853 /// for the purpose of lifetime-extending a temporary bound to a reference in
5854 /// the initialization of \p Entity.
5855 static const InitializedEntity *getEntityForTemporaryLifetimeExtension(
5856     const InitializedEntity *Entity,
5857     const InitializedEntity *FallbackDecl = nullptr) {
5858   // C++11 [class.temporary]p5:
5859   switch (Entity->getKind()) {
5860   case InitializedEntity::EK_Variable:
5861     //   The temporary [...] persists for the lifetime of the reference
5862     return Entity;
5863 
5864   case InitializedEntity::EK_Member:
5865     // For subobjects, we look at the complete object.
5866     if (Entity->getParent())
5867       return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
5868                                                     Entity);
5869 
5870     //   except:
5871     //   -- A temporary bound to a reference member in a constructor's
5872     //      ctor-initializer persists until the constructor exits.
5873     return Entity;
5874 
5875   case InitializedEntity::EK_Binding:
5876     // Per [dcl.decomp]p3, the binding is treated as a variable of reference
5877     // type.
5878     return Entity;
5879 
5880   case InitializedEntity::EK_Parameter:
5881   case InitializedEntity::EK_Parameter_CF_Audited:
5882     //   -- A temporary bound to a reference parameter in a function call
5883     //      persists until the completion of the full-expression containing
5884     //      the call.
5885   case InitializedEntity::EK_Result:
5886     //   -- The lifetime of a temporary bound to the returned value in a
5887     //      function return statement is not extended; the temporary is
5888     //      destroyed at the end of the full-expression in the return statement.
5889   case InitializedEntity::EK_New:
5890     //   -- A temporary bound to a reference in a new-initializer persists
5891     //      until the completion of the full-expression containing the
5892     //      new-initializer.
5893     return nullptr;
5894 
5895   case InitializedEntity::EK_Temporary:
5896   case InitializedEntity::EK_CompoundLiteralInit:
5897   case InitializedEntity::EK_RelatedResult:
5898     // We don't yet know the storage duration of the surrounding temporary.
5899     // Assume it's got full-expression duration for now, it will patch up our
5900     // storage duration if that's not correct.
5901     return nullptr;
5902 
5903   case InitializedEntity::EK_ArrayElement:
5904     // For subobjects, we look at the complete object.
5905     return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
5906                                                   FallbackDecl);
5907 
5908   case InitializedEntity::EK_Base:
5909     // For subobjects, we look at the complete object.
5910     if (Entity->getParent())
5911       return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
5912                                                     Entity);
5913     // Fall through.
5914   case InitializedEntity::EK_Delegating:
5915     // We can reach this case for aggregate initialization in a constructor:
5916     //   struct A { int &&r; };
5917     //   struct B : A { B() : A{0} {} };
5918     // In this case, use the innermost field decl as the context.
5919     return FallbackDecl;
5920 
5921   case InitializedEntity::EK_BlockElement:
5922   case InitializedEntity::EK_LambdaCapture:
5923   case InitializedEntity::EK_Exception:
5924   case InitializedEntity::EK_VectorElement:
5925   case InitializedEntity::EK_ComplexElement:
5926     return nullptr;
5927   }
5928   llvm_unreachable("unknown entity kind");
5929 }
5930 
5931 static void performLifetimeExtension(Expr *Init,
5932                                      const InitializedEntity *ExtendingEntity);
5933 
5934 /// Update a glvalue expression that is used as the initializer of a reference
5935 /// to note that its lifetime is extended.
5936 /// \return \c true if any temporary had its lifetime extended.
5937 static bool
5938 performReferenceExtension(Expr *Init,
5939                           const InitializedEntity *ExtendingEntity) {
5940   // Walk past any constructs which we can lifetime-extend across.
5941   Expr *Old;
5942   do {
5943     Old = Init;
5944 
5945     if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5946       if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
5947         // This is just redundant braces around an initializer. Step over it.
5948         Init = ILE->getInit(0);
5949       }
5950     }
5951 
5952     // Step over any subobject adjustments; we may have a materialized
5953     // temporary inside them.
5954     SmallVector<const Expr *, 2> CommaLHSs;
5955     SmallVector<SubobjectAdjustment, 2> Adjustments;
5956     Init = const_cast<Expr *>(
5957         Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5958 
5959     // Per current approach for DR1376, look through casts to reference type
5960     // when performing lifetime extension.
5961     if (CastExpr *CE = dyn_cast<CastExpr>(Init))
5962       if (CE->getSubExpr()->isGLValue())
5963         Init = CE->getSubExpr();
5964 
5965     // FIXME: Per DR1213, subscripting on an array temporary produces an xvalue.
5966     // It's unclear if binding a reference to that xvalue extends the array
5967     // temporary.
5968   } while (Init != Old);
5969 
5970   if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) {
5971     // Update the storage duration of the materialized temporary.
5972     // FIXME: Rebuild the expression instead of mutating it.
5973     ME->setExtendingDecl(ExtendingEntity->getDecl(),
5974                          ExtendingEntity->allocateManglingNumber());
5975     performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingEntity);
5976     return true;
5977   }
5978 
5979   return false;
5980 }
5981 
5982 /// Update a prvalue expression that is going to be materialized as a
5983 /// lifetime-extended temporary.
5984 static void performLifetimeExtension(Expr *Init,
5985                                      const InitializedEntity *ExtendingEntity) {
5986   // Dig out the expression which constructs the extended temporary.
5987   SmallVector<const Expr *, 2> CommaLHSs;
5988   SmallVector<SubobjectAdjustment, 2> Adjustments;
5989   Init = const_cast<Expr *>(
5990       Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5991 
5992   if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init))
5993     Init = BTE->getSubExpr();
5994 
5995   if (CXXStdInitializerListExpr *ILE =
5996           dyn_cast<CXXStdInitializerListExpr>(Init)) {
5997     performReferenceExtension(ILE->getSubExpr(), ExtendingEntity);
5998     return;
5999   }
6000 
6001   if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
6002     if (ILE->getType()->isArrayType()) {
6003       for (unsigned I = 0, N = ILE->getNumInits(); I != N; ++I)
6004         performLifetimeExtension(ILE->getInit(I), ExtendingEntity);
6005       return;
6006     }
6007 
6008     if (CXXRecordDecl *RD = ILE->getType()->getAsCXXRecordDecl()) {
6009       assert(RD->isAggregate() && "aggregate init on non-aggregate");
6010 
6011       // If we lifetime-extend a braced initializer which is initializing an
6012       // aggregate, and that aggregate contains reference members which are
6013       // bound to temporaries, those temporaries are also lifetime-extended.
6014       if (RD->isUnion() && ILE->getInitializedFieldInUnion() &&
6015           ILE->getInitializedFieldInUnion()->getType()->isReferenceType())
6016         performReferenceExtension(ILE->getInit(0), ExtendingEntity);
6017       else {
6018         unsigned Index = 0;
6019         for (const auto *I : RD->fields()) {
6020           if (Index >= ILE->getNumInits())
6021             break;
6022           if (I->isUnnamedBitfield())
6023             continue;
6024           Expr *SubInit = ILE->getInit(Index);
6025           if (I->getType()->isReferenceType())
6026             performReferenceExtension(SubInit, ExtendingEntity);
6027           else if (isa<InitListExpr>(SubInit) ||
6028                    isa<CXXStdInitializerListExpr>(SubInit))
6029             // This may be either aggregate-initialization of a member or
6030             // initialization of a std::initializer_list object. Either way,
6031             // we should recursively lifetime-extend that initializer.
6032             performLifetimeExtension(SubInit, ExtendingEntity);
6033           ++Index;
6034         }
6035       }
6036     }
6037   }
6038 }
6039 
6040 static void warnOnLifetimeExtension(Sema &S, const InitializedEntity &Entity,
6041                                     const Expr *Init, bool IsInitializerList,
6042                                     const ValueDecl *ExtendingDecl) {
6043   // Warn if a field lifetime-extends a temporary.
6044   if (isa<FieldDecl>(ExtendingDecl)) {
6045     if (IsInitializerList) {
6046       S.Diag(Init->getExprLoc(), diag::warn_dangling_std_initializer_list)
6047         << /*at end of constructor*/true;
6048       return;
6049     }
6050 
6051     bool IsSubobjectMember = false;
6052     for (const InitializedEntity *Ent = Entity.getParent(); Ent;
6053          Ent = Ent->getParent()) {
6054       if (Ent->getKind() != InitializedEntity::EK_Base) {
6055         IsSubobjectMember = true;
6056         break;
6057       }
6058     }
6059     S.Diag(Init->getExprLoc(),
6060            diag::warn_bind_ref_member_to_temporary)
6061       << ExtendingDecl << Init->getSourceRange()
6062       << IsSubobjectMember << IsInitializerList;
6063     if (IsSubobjectMember)
6064       S.Diag(ExtendingDecl->getLocation(),
6065              diag::note_ref_subobject_of_member_declared_here);
6066     else
6067       S.Diag(ExtendingDecl->getLocation(),
6068              diag::note_ref_or_ptr_member_declared_here)
6069         << /*is pointer*/false;
6070   }
6071 }
6072 
6073 static void DiagnoseNarrowingInInitList(Sema &S,
6074                                         const ImplicitConversionSequence &ICS,
6075                                         QualType PreNarrowingType,
6076                                         QualType EntityType,
6077                                         const Expr *PostInit);
6078 
6079 /// Provide warnings when std::move is used on construction.
6080 static void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr,
6081                                     bool IsReturnStmt) {
6082   if (!InitExpr)
6083     return;
6084 
6085   if (!S.ActiveTemplateInstantiations.empty())
6086     return;
6087 
6088   QualType DestType = InitExpr->getType();
6089   if (!DestType->isRecordType())
6090     return;
6091 
6092   unsigned DiagID = 0;
6093   if (IsReturnStmt) {
6094     const CXXConstructExpr *CCE =
6095         dyn_cast<CXXConstructExpr>(InitExpr->IgnoreParens());
6096     if (!CCE || CCE->getNumArgs() != 1)
6097       return;
6098 
6099     if (!CCE->getConstructor()->isCopyOrMoveConstructor())
6100       return;
6101 
6102     InitExpr = CCE->getArg(0)->IgnoreImpCasts();
6103   }
6104 
6105   // Find the std::move call and get the argument.
6106   const CallExpr *CE = dyn_cast<CallExpr>(InitExpr->IgnoreParens());
6107   if (!CE || CE->getNumArgs() != 1)
6108     return;
6109 
6110   const FunctionDecl *MoveFunction = CE->getDirectCallee();
6111   if (!MoveFunction || !MoveFunction->isInStdNamespace() ||
6112       !MoveFunction->getIdentifier() ||
6113       !MoveFunction->getIdentifier()->isStr("move"))
6114     return;
6115 
6116   const Expr *Arg = CE->getArg(0)->IgnoreImplicit();
6117 
6118   if (IsReturnStmt) {
6119     const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts());
6120     if (!DRE || DRE->refersToEnclosingVariableOrCapture())
6121       return;
6122 
6123     const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl());
6124     if (!VD || !VD->hasLocalStorage())
6125       return;
6126 
6127     QualType SourceType = VD->getType();
6128     if (!SourceType->isRecordType())
6129       return;
6130 
6131     if (!S.Context.hasSameUnqualifiedType(DestType, SourceType)) {
6132       return;
6133     }
6134 
6135     // If we're returning a function parameter, copy elision
6136     // is not possible.
6137     if (isa<ParmVarDecl>(VD))
6138       DiagID = diag::warn_redundant_move_on_return;
6139     else
6140       DiagID = diag::warn_pessimizing_move_on_return;
6141   } else {
6142     DiagID = diag::warn_pessimizing_move_on_initialization;
6143     const Expr *ArgStripped = Arg->IgnoreImplicit()->IgnoreParens();
6144     if (!ArgStripped->isRValue() || !ArgStripped->getType()->isRecordType())
6145       return;
6146   }
6147 
6148   S.Diag(CE->getLocStart(), DiagID);
6149 
6150   // Get all the locations for a fix-it.  Don't emit the fix-it if any location
6151   // is within a macro.
6152   SourceLocation CallBegin = CE->getCallee()->getLocStart();
6153   if (CallBegin.isMacroID())
6154     return;
6155   SourceLocation RParen = CE->getRParenLoc();
6156   if (RParen.isMacroID())
6157     return;
6158   SourceLocation LParen;
6159   SourceLocation ArgLoc = Arg->getLocStart();
6160 
6161   // Special testing for the argument location.  Since the fix-it needs the
6162   // location right before the argument, the argument location can be in a
6163   // macro only if it is at the beginning of the macro.
6164   while (ArgLoc.isMacroID() &&
6165          S.getSourceManager().isAtStartOfImmediateMacroExpansion(ArgLoc)) {
6166     ArgLoc = S.getSourceManager().getImmediateExpansionRange(ArgLoc).first;
6167   }
6168 
6169   if (LParen.isMacroID())
6170     return;
6171 
6172   LParen = ArgLoc.getLocWithOffset(-1);
6173 
6174   S.Diag(CE->getLocStart(), diag::note_remove_move)
6175       << FixItHint::CreateRemoval(SourceRange(CallBegin, LParen))
6176       << FixItHint::CreateRemoval(SourceRange(RParen, RParen));
6177 }
6178 
6179 static void CheckForNullPointerDereference(Sema &S, const Expr *E) {
6180   // Check to see if we are dereferencing a null pointer.  If so, this is
6181   // undefined behavior, so warn about it.  This only handles the pattern
6182   // "*null", which is a very syntactic check.
6183   if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts()))
6184     if (UO->getOpcode() == UO_Deref &&
6185         UO->getSubExpr()->IgnoreParenCasts()->
6186         isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull)) {
6187     S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO,
6188                           S.PDiag(diag::warn_binding_null_to_reference)
6189                             << UO->getSubExpr()->getSourceRange());
6190   }
6191 }
6192 
6193 MaterializeTemporaryExpr *
6194 Sema::CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,
6195                                      bool BoundToLvalueReference) {
6196   auto MTE = new (Context)
6197       MaterializeTemporaryExpr(T, Temporary, BoundToLvalueReference);
6198 
6199   // Order an ExprWithCleanups for lifetime marks.
6200   //
6201   // TODO: It'll be good to have a single place to check the access of the
6202   // destructor and generate ExprWithCleanups for various uses. Currently these
6203   // are done in both CreateMaterializeTemporaryExpr and MaybeBindToTemporary,
6204   // but there may be a chance to merge them.
6205   Cleanup.setExprNeedsCleanups(false);
6206   return MTE;
6207 }
6208 
6209 ExprResult
6210 InitializationSequence::Perform(Sema &S,
6211                                 const InitializedEntity &Entity,
6212                                 const InitializationKind &Kind,
6213                                 MultiExprArg Args,
6214                                 QualType *ResultType) {
6215   if (Failed()) {
6216     Diagnose(S, Entity, Kind, Args);
6217     return ExprError();
6218   }
6219   if (!ZeroInitializationFixit.empty()) {
6220     unsigned DiagID = diag::err_default_init_const;
6221     if (Decl *D = Entity.getDecl())
6222       if (S.getLangOpts().MSVCCompat && D->hasAttr<SelectAnyAttr>())
6223         DiagID = diag::ext_default_init_const;
6224 
6225     // The initialization would have succeeded with this fixit. Since the fixit
6226     // is on the error, we need to build a valid AST in this case, so this isn't
6227     // handled in the Failed() branch above.
6228     QualType DestType = Entity.getType();
6229     S.Diag(Kind.getLocation(), DiagID)
6230         << DestType << (bool)DestType->getAs<RecordType>()
6231         << FixItHint::CreateInsertion(ZeroInitializationFixitLoc,
6232                                       ZeroInitializationFixit);
6233   }
6234 
6235   if (getKind() == DependentSequence) {
6236     // If the declaration is a non-dependent, incomplete array type
6237     // that has an initializer, then its type will be completed once
6238     // the initializer is instantiated.
6239     if (ResultType && !Entity.getType()->isDependentType() &&
6240         Args.size() == 1) {
6241       QualType DeclType = Entity.getType();
6242       if (const IncompleteArrayType *ArrayT
6243                            = S.Context.getAsIncompleteArrayType(DeclType)) {
6244         // FIXME: We don't currently have the ability to accurately
6245         // compute the length of an initializer list without
6246         // performing full type-checking of the initializer list
6247         // (since we have to determine where braces are implicitly
6248         // introduced and such).  So, we fall back to making the array
6249         // type a dependently-sized array type with no specified
6250         // bound.
6251         if (isa<InitListExpr>((Expr *)Args[0])) {
6252           SourceRange Brackets;
6253 
6254           // Scavange the location of the brackets from the entity, if we can.
6255           if (auto *DD = dyn_cast_or_null<DeclaratorDecl>(Entity.getDecl())) {
6256             if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
6257               TypeLoc TL = TInfo->getTypeLoc();
6258               if (IncompleteArrayTypeLoc ArrayLoc =
6259                       TL.getAs<IncompleteArrayTypeLoc>())
6260                 Brackets = ArrayLoc.getBracketsRange();
6261             }
6262           }
6263 
6264           *ResultType
6265             = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
6266                                                    /*NumElts=*/nullptr,
6267                                                    ArrayT->getSizeModifier(),
6268                                        ArrayT->getIndexTypeCVRQualifiers(),
6269                                                    Brackets);
6270         }
6271 
6272       }
6273     }
6274     if (Kind.getKind() == InitializationKind::IK_Direct &&
6275         !Kind.isExplicitCast()) {
6276       // Rebuild the ParenListExpr.
6277       SourceRange ParenRange = Kind.getParenRange();
6278       return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(),
6279                                   Args);
6280     }
6281     assert(Kind.getKind() == InitializationKind::IK_Copy ||
6282            Kind.isExplicitCast() ||
6283            Kind.getKind() == InitializationKind::IK_DirectList);
6284     return ExprResult(Args[0]);
6285   }
6286 
6287   // No steps means no initialization.
6288   if (Steps.empty())
6289     return ExprResult((Expr *)nullptr);
6290 
6291   if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
6292       Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
6293       !Entity.isParameterKind()) {
6294     // Produce a C++98 compatibility warning if we are initializing a reference
6295     // from an initializer list. For parameters, we produce a better warning
6296     // elsewhere.
6297     Expr *Init = Args[0];
6298     S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
6299       << Init->getSourceRange();
6300   }
6301 
6302   // Diagnose cases where we initialize a pointer to an array temporary, and the
6303   // pointer obviously outlives the temporary.
6304   if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
6305       Entity.getType()->isPointerType() &&
6306       InitializedEntityOutlivesFullExpression(Entity)) {
6307     Expr *Init = Args[0];
6308     Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context);
6309     if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
6310       S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
6311         << Init->getSourceRange();
6312   }
6313 
6314   QualType DestType = Entity.getType().getNonReferenceType();
6315   // FIXME: Ugly hack around the fact that Entity.getType() is not
6316   // the same as Entity.getDecl()->getType() in cases involving type merging,
6317   //  and we want latter when it makes sense.
6318   if (ResultType)
6319     *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
6320                                      Entity.getType();
6321 
6322   ExprResult CurInit((Expr *)nullptr);
6323 
6324   // For initialization steps that start with a single initializer,
6325   // grab the only argument out the Args and place it into the "current"
6326   // initializer.
6327   switch (Steps.front().Kind) {
6328   case SK_ResolveAddressOfOverloadedFunction:
6329   case SK_CastDerivedToBaseRValue:
6330   case SK_CastDerivedToBaseXValue:
6331   case SK_CastDerivedToBaseLValue:
6332   case SK_BindReference:
6333   case SK_BindReferenceToTemporary:
6334   case SK_ExtraneousCopyToTemporary:
6335   case SK_UserConversion:
6336   case SK_QualificationConversionLValue:
6337   case SK_QualificationConversionXValue:
6338   case SK_QualificationConversionRValue:
6339   case SK_AtomicConversion:
6340   case SK_LValueToRValue:
6341   case SK_ConversionSequence:
6342   case SK_ConversionSequenceNoNarrowing:
6343   case SK_ListInitialization:
6344   case SK_UnwrapInitList:
6345   case SK_RewrapInitList:
6346   case SK_CAssignment:
6347   case SK_StringInit:
6348   case SK_ObjCObjectConversion:
6349   case SK_ArrayInit:
6350   case SK_ParenthesizedArrayInit:
6351   case SK_PassByIndirectCopyRestore:
6352   case SK_PassByIndirectRestore:
6353   case SK_ProduceObjCObject:
6354   case SK_StdInitializerList:
6355   case SK_OCLSamplerInit:
6356   case SK_OCLZeroEvent: {
6357     assert(Args.size() == 1);
6358     CurInit = Args[0];
6359     if (!CurInit.get()) return ExprError();
6360     break;
6361   }
6362 
6363   case SK_ConstructorInitialization:
6364   case SK_ConstructorInitializationFromList:
6365   case SK_StdInitializerListConstructorCall:
6366   case SK_ZeroInitialization:
6367     break;
6368   }
6369 
6370   // Walk through the computed steps for the initialization sequence,
6371   // performing the specified conversions along the way.
6372   bool ConstructorInitRequiresZeroInit = false;
6373   for (step_iterator Step = step_begin(), StepEnd = step_end();
6374        Step != StepEnd; ++Step) {
6375     if (CurInit.isInvalid())
6376       return ExprError();
6377 
6378     QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
6379 
6380     switch (Step->Kind) {
6381     case SK_ResolveAddressOfOverloadedFunction:
6382       // Overload resolution determined which function invoke; update the
6383       // initializer to reflect that choice.
6384       S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
6385       if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()))
6386         return ExprError();
6387       CurInit = S.FixOverloadedFunctionReference(CurInit,
6388                                                  Step->Function.FoundDecl,
6389                                                  Step->Function.Function);
6390       break;
6391 
6392     case SK_CastDerivedToBaseRValue:
6393     case SK_CastDerivedToBaseXValue:
6394     case SK_CastDerivedToBaseLValue: {
6395       // We have a derived-to-base cast that produces either an rvalue or an
6396       // lvalue. Perform that cast.
6397 
6398       CXXCastPath BasePath;
6399 
6400       // Casts to inaccessible base classes are allowed with C-style casts.
6401       bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
6402       if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
6403                                          CurInit.get()->getLocStart(),
6404                                          CurInit.get()->getSourceRange(),
6405                                          &BasePath, IgnoreBaseAccess))
6406         return ExprError();
6407 
6408       ExprValueKind VK =
6409           Step->Kind == SK_CastDerivedToBaseLValue ?
6410               VK_LValue :
6411               (Step->Kind == SK_CastDerivedToBaseXValue ?
6412                    VK_XValue :
6413                    VK_RValue);
6414       CurInit =
6415           ImplicitCastExpr::Create(S.Context, Step->Type, CK_DerivedToBase,
6416                                    CurInit.get(), &BasePath, VK);
6417       break;
6418     }
6419 
6420     case SK_BindReference:
6421       // References cannot bind to bit-fields (C++ [dcl.init.ref]p5).
6422       if (CurInit.get()->refersToBitField()) {
6423         // We don't necessarily have an unambiguous source bit-field.
6424         FieldDecl *BitField = CurInit.get()->getSourceBitField();
6425         S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
6426           << Entity.getType().isVolatileQualified()
6427           << (BitField ? BitField->getDeclName() : DeclarationName())
6428           << (BitField != nullptr)
6429           << CurInit.get()->getSourceRange();
6430         if (BitField)
6431           S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
6432 
6433         return ExprError();
6434       }
6435 
6436       if (CurInit.get()->refersToVectorElement()) {
6437         // References cannot bind to vector elements.
6438         S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
6439           << Entity.getType().isVolatileQualified()
6440           << CurInit.get()->getSourceRange();
6441         PrintInitLocationNote(S, Entity);
6442         return ExprError();
6443       }
6444 
6445       // Reference binding does not have any corresponding ASTs.
6446 
6447       // Check exception specifications
6448       if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
6449         return ExprError();
6450 
6451       // Even though we didn't materialize a temporary, the binding may still
6452       // extend the lifetime of a temporary. This happens if we bind a reference
6453       // to the result of a cast to reference type.
6454       if (const InitializedEntity *ExtendingEntity =
6455               getEntityForTemporaryLifetimeExtension(&Entity))
6456         if (performReferenceExtension(CurInit.get(), ExtendingEntity))
6457           warnOnLifetimeExtension(S, Entity, CurInit.get(),
6458                                   /*IsInitializerList=*/false,
6459                                   ExtendingEntity->getDecl());
6460 
6461       CheckForNullPointerDereference(S, CurInit.get());
6462       break;
6463 
6464     case SK_BindReferenceToTemporary: {
6465       // Make sure the "temporary" is actually an rvalue.
6466       assert(CurInit.get()->isRValue() && "not a temporary");
6467 
6468       // Check exception specifications
6469       if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
6470         return ExprError();
6471 
6472       // Materialize the temporary into memory.
6473       MaterializeTemporaryExpr *MTE = S.CreateMaterializeTemporaryExpr(
6474           Entity.getType().getNonReferenceType(), CurInit.get(),
6475           Entity.getType()->isLValueReferenceType());
6476 
6477       // Maybe lifetime-extend the temporary's subobjects to match the
6478       // entity's lifetime.
6479       if (const InitializedEntity *ExtendingEntity =
6480               getEntityForTemporaryLifetimeExtension(&Entity))
6481         if (performReferenceExtension(MTE, ExtendingEntity))
6482           warnOnLifetimeExtension(S, Entity, CurInit.get(), /*IsInitializerList=*/false,
6483                                   ExtendingEntity->getDecl());
6484 
6485       // If we're binding to an Objective-C object that has lifetime, we
6486       // need cleanups. Likewise if we're extending this temporary to automatic
6487       // storage duration -- we need to register its cleanup during the
6488       // full-expression's cleanups.
6489       if ((S.getLangOpts().ObjCAutoRefCount &&
6490            MTE->getType()->isObjCLifetimeType()) ||
6491           (MTE->getStorageDuration() == SD_Automatic &&
6492            MTE->getType().isDestructedType()))
6493         S.Cleanup.setExprNeedsCleanups(true);
6494 
6495       CurInit = MTE;
6496       break;
6497     }
6498 
6499     case SK_ExtraneousCopyToTemporary:
6500       CurInit = CopyObject(S, Step->Type, Entity, CurInit,
6501                            /*IsExtraneousCopy=*/true);
6502       break;
6503 
6504     case SK_UserConversion: {
6505       // We have a user-defined conversion that invokes either a constructor
6506       // or a conversion function.
6507       CastKind CastKind;
6508       bool IsCopy = false;
6509       FunctionDecl *Fn = Step->Function.Function;
6510       DeclAccessPair FoundFn = Step->Function.FoundDecl;
6511       bool HadMultipleCandidates = Step->Function.HadMultipleCandidates;
6512       bool CreatedObject = false;
6513       if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
6514         // Build a call to the selected constructor.
6515         SmallVector<Expr*, 8> ConstructorArgs;
6516         SourceLocation Loc = CurInit.get()->getLocStart();
6517         CurInit.get(); // Ownership transferred into MultiExprArg, below.
6518 
6519         // Determine the arguments required to actually perform the constructor
6520         // call.
6521         Expr *Arg = CurInit.get();
6522         if (S.CompleteConstructorCall(Constructor,
6523                                       MultiExprArg(&Arg, 1),
6524                                       Loc, ConstructorArgs))
6525           return ExprError();
6526 
6527         // Build an expression that constructs a temporary.
6528         CurInit = S.BuildCXXConstructExpr(Loc, Step->Type,
6529                                           FoundFn, Constructor,
6530                                           ConstructorArgs,
6531                                           HadMultipleCandidates,
6532                                           /*ListInit*/ false,
6533                                           /*StdInitListInit*/ false,
6534                                           /*ZeroInit*/ false,
6535                                           CXXConstructExpr::CK_Complete,
6536                                           SourceRange());
6537         if (CurInit.isInvalid())
6538           return ExprError();
6539 
6540         S.CheckConstructorAccess(Kind.getLocation(), Constructor, FoundFn,
6541                                  Entity);
6542         if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
6543           return ExprError();
6544 
6545         CastKind = CK_ConstructorConversion;
6546         QualType Class = S.Context.getTypeDeclType(Constructor->getParent());
6547         if (S.Context.hasSameUnqualifiedType(SourceType, Class) ||
6548             S.IsDerivedFrom(Loc, SourceType, Class))
6549           IsCopy = true;
6550 
6551         CreatedObject = true;
6552       } else {
6553         // Build a call to the conversion function.
6554         CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
6555         S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), nullptr,
6556                                     FoundFn);
6557         if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
6558           return ExprError();
6559 
6560         // FIXME: Should we move this initialization into a separate
6561         // derived-to-base conversion? I believe the answer is "no", because
6562         // we don't want to turn off access control here for c-style casts.
6563         ExprResult CurInitExprRes =
6564           S.PerformObjectArgumentInitialization(CurInit.get(),
6565                                                 /*Qualifier=*/nullptr,
6566                                                 FoundFn, Conversion);
6567         if(CurInitExprRes.isInvalid())
6568           return ExprError();
6569         CurInit = CurInitExprRes;
6570 
6571         // Build the actual call to the conversion function.
6572         CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion,
6573                                            HadMultipleCandidates);
6574         if (CurInit.isInvalid() || !CurInit.get())
6575           return ExprError();
6576 
6577         CastKind = CK_UserDefinedConversion;
6578 
6579         CreatedObject = Conversion->getReturnType()->isRecordType();
6580       }
6581 
6582       bool RequiresCopy = !IsCopy && !isReferenceBinding(Steps.back());
6583       bool MaybeBindToTemp = RequiresCopy || shouldBindAsTemporary(Entity);
6584 
6585       if (!MaybeBindToTemp && CreatedObject && shouldDestroyTemporary(Entity)) {
6586         QualType T = CurInit.get()->getType();
6587         if (const RecordType *Record = T->getAs<RecordType>()) {
6588           CXXDestructorDecl *Destructor
6589             = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl()));
6590           S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor,
6591                                   S.PDiag(diag::err_access_dtor_temp) << T);
6592           S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor);
6593           if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart()))
6594             return ExprError();
6595         }
6596       }
6597 
6598       CurInit = ImplicitCastExpr::Create(S.Context, CurInit.get()->getType(),
6599                                          CastKind, CurInit.get(), nullptr,
6600                                          CurInit.get()->getValueKind());
6601       if (MaybeBindToTemp)
6602         CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
6603       if (RequiresCopy)
6604         CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity,
6605                              CurInit, /*IsExtraneousCopy=*/false);
6606       break;
6607     }
6608 
6609     case SK_QualificationConversionLValue:
6610     case SK_QualificationConversionXValue:
6611     case SK_QualificationConversionRValue: {
6612       // Perform a qualification conversion; these can never go wrong.
6613       ExprValueKind VK =
6614           Step->Kind == SK_QualificationConversionLValue ?
6615               VK_LValue :
6616               (Step->Kind == SK_QualificationConversionXValue ?
6617                    VK_XValue :
6618                    VK_RValue);
6619       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type, CK_NoOp, VK);
6620       break;
6621     }
6622 
6623     case SK_AtomicConversion: {
6624       assert(CurInit.get()->isRValue() && "cannot convert glvalue to atomic");
6625       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6626                                     CK_NonAtomicToAtomic, VK_RValue);
6627       break;
6628     }
6629 
6630     case SK_LValueToRValue: {
6631       assert(CurInit.get()->isGLValue() && "cannot load from a prvalue");
6632       CurInit = ImplicitCastExpr::Create(S.Context, Step->Type,
6633                                          CK_LValueToRValue, CurInit.get(),
6634                                          /*BasePath=*/nullptr, VK_RValue);
6635       break;
6636     }
6637 
6638     case SK_ConversionSequence:
6639     case SK_ConversionSequenceNoNarrowing: {
6640       Sema::CheckedConversionKind CCK
6641         = Kind.isCStyleCast()? Sema::CCK_CStyleCast
6642         : Kind.isFunctionalCast()? Sema::CCK_FunctionalCast
6643         : Kind.isExplicitCast()? Sema::CCK_OtherCast
6644         : Sema::CCK_ImplicitConversion;
6645       ExprResult CurInitExprRes =
6646         S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,
6647                                     getAssignmentAction(Entity), CCK);
6648       if (CurInitExprRes.isInvalid())
6649         return ExprError();
6650 
6651       S.DiscardMisalignedMemberAddress(Step->Type.getTypePtr(), CurInit.get());
6652 
6653       CurInit = CurInitExprRes;
6654 
6655       if (Step->Kind == SK_ConversionSequenceNoNarrowing &&
6656           S.getLangOpts().CPlusPlus && !CurInit.get()->isValueDependent())
6657         DiagnoseNarrowingInInitList(S, *Step->ICS, SourceType, Entity.getType(),
6658                                     CurInit.get());
6659 
6660       break;
6661     }
6662 
6663     case SK_ListInitialization: {
6664       InitListExpr *InitList = cast<InitListExpr>(CurInit.get());
6665       // If we're not initializing the top-level entity, we need to create an
6666       // InitializeTemporary entity for our target type.
6667       QualType Ty = Step->Type;
6668       bool IsTemporary = !S.Context.hasSameType(Entity.getType(), Ty);
6669       InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(Ty);
6670       InitializedEntity InitEntity = IsTemporary ? TempEntity : Entity;
6671       InitListChecker PerformInitList(S, InitEntity,
6672           InitList, Ty, /*VerifyOnly=*/false,
6673           /*TreatUnavailableAsInvalid=*/false);
6674       if (PerformInitList.HadError())
6675         return ExprError();
6676 
6677       // Hack: We must update *ResultType if available in order to set the
6678       // bounds of arrays, e.g. in 'int ar[] = {1, 2, 3};'.
6679       // Worst case: 'const int (&arref)[] = {1, 2, 3};'.
6680       if (ResultType &&
6681           ResultType->getNonReferenceType()->isIncompleteArrayType()) {
6682         if ((*ResultType)->isRValueReferenceType())
6683           Ty = S.Context.getRValueReferenceType(Ty);
6684         else if ((*ResultType)->isLValueReferenceType())
6685           Ty = S.Context.getLValueReferenceType(Ty,
6686             (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue());
6687         *ResultType = Ty;
6688       }
6689 
6690       InitListExpr *StructuredInitList =
6691           PerformInitList.getFullyStructuredList();
6692       CurInit.get();
6693       CurInit = shouldBindAsTemporary(InitEntity)
6694           ? S.MaybeBindToTemporary(StructuredInitList)
6695           : StructuredInitList;
6696       break;
6697     }
6698 
6699     case SK_ConstructorInitializationFromList: {
6700       // When an initializer list is passed for a parameter of type "reference
6701       // to object", we don't get an EK_Temporary entity, but instead an
6702       // EK_Parameter entity with reference type.
6703       // FIXME: This is a hack. What we really should do is create a user
6704       // conversion step for this case, but this makes it considerably more
6705       // complicated. For now, this will do.
6706       InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6707                                         Entity.getType().getNonReferenceType());
6708       bool UseTemporary = Entity.getType()->isReferenceType();
6709       assert(Args.size() == 1 && "expected a single argument for list init");
6710       InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6711       S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
6712         << InitList->getSourceRange();
6713       MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
6714       CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
6715                                                                    Entity,
6716                                                  Kind, Arg, *Step,
6717                                                ConstructorInitRequiresZeroInit,
6718                                                /*IsListInitialization*/true,
6719                                                /*IsStdInitListInit*/false,
6720                                                InitList->getLBraceLoc(),
6721                                                InitList->getRBraceLoc());
6722       break;
6723     }
6724 
6725     case SK_UnwrapInitList:
6726       CurInit = cast<InitListExpr>(CurInit.get())->getInit(0);
6727       break;
6728 
6729     case SK_RewrapInitList: {
6730       Expr *E = CurInit.get();
6731       InitListExpr *Syntactic = Step->WrappingSyntacticList;
6732       InitListExpr *ILE = new (S.Context) InitListExpr(S.Context,
6733           Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc());
6734       ILE->setSyntacticForm(Syntactic);
6735       ILE->setType(E->getType());
6736       ILE->setValueKind(E->getValueKind());
6737       CurInit = ILE;
6738       break;
6739     }
6740 
6741     case SK_ConstructorInitialization:
6742     case SK_StdInitializerListConstructorCall: {
6743       // When an initializer list is passed for a parameter of type "reference
6744       // to object", we don't get an EK_Temporary entity, but instead an
6745       // EK_Parameter entity with reference type.
6746       // FIXME: This is a hack. What we really should do is create a user
6747       // conversion step for this case, but this makes it considerably more
6748       // complicated. For now, this will do.
6749       InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6750                                         Entity.getType().getNonReferenceType());
6751       bool UseTemporary = Entity.getType()->isReferenceType();
6752       bool IsStdInitListInit =
6753           Step->Kind == SK_StdInitializerListConstructorCall;
6754       CurInit = PerformConstructorInitialization(
6755           S, UseTemporary ? TempEntity : Entity, Kind, Args, *Step,
6756           ConstructorInitRequiresZeroInit,
6757           /*IsListInitialization*/IsStdInitListInit,
6758           /*IsStdInitListInitialization*/IsStdInitListInit,
6759           /*LBraceLoc*/SourceLocation(),
6760           /*RBraceLoc*/SourceLocation());
6761       break;
6762     }
6763 
6764     case SK_ZeroInitialization: {
6765       step_iterator NextStep = Step;
6766       ++NextStep;
6767       if (NextStep != StepEnd &&
6768           (NextStep->Kind == SK_ConstructorInitialization ||
6769            NextStep->Kind == SK_ConstructorInitializationFromList)) {
6770         // The need for zero-initialization is recorded directly into
6771         // the call to the object's constructor within the next step.
6772         ConstructorInitRequiresZeroInit = true;
6773       } else if (Kind.getKind() == InitializationKind::IK_Value &&
6774                  S.getLangOpts().CPlusPlus &&
6775                  !Kind.isImplicitValueInit()) {
6776         TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
6777         if (!TSInfo)
6778           TSInfo = S.Context.getTrivialTypeSourceInfo(Step->Type,
6779                                                     Kind.getRange().getBegin());
6780 
6781         CurInit = new (S.Context) CXXScalarValueInitExpr(
6782             TSInfo->getType().getNonLValueExprType(S.Context), TSInfo,
6783             Kind.getRange().getEnd());
6784       } else {
6785         CurInit = new (S.Context) ImplicitValueInitExpr(Step->Type);
6786       }
6787       break;
6788     }
6789 
6790     case SK_CAssignment: {
6791       QualType SourceType = CurInit.get()->getType();
6792       // Save off the initial CurInit in case we need to emit a diagnostic
6793       ExprResult InitialCurInit = CurInit;
6794       ExprResult Result = CurInit;
6795       Sema::AssignConvertType ConvTy =
6796         S.CheckSingleAssignmentConstraints(Step->Type, Result, true,
6797             Entity.getKind() == InitializedEntity::EK_Parameter_CF_Audited);
6798       if (Result.isInvalid())
6799         return ExprError();
6800       CurInit = Result;
6801 
6802       // If this is a call, allow conversion to a transparent union.
6803       ExprResult CurInitExprRes = CurInit;
6804       if (ConvTy != Sema::Compatible &&
6805           Entity.isParameterKind() &&
6806           S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExprRes)
6807             == Sema::Compatible)
6808         ConvTy = Sema::Compatible;
6809       if (CurInitExprRes.isInvalid())
6810         return ExprError();
6811       CurInit = CurInitExprRes;
6812 
6813       bool Complained;
6814       if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
6815                                      Step->Type, SourceType,
6816                                      InitialCurInit.get(),
6817                                      getAssignmentAction(Entity, true),
6818                                      &Complained)) {
6819         PrintInitLocationNote(S, Entity);
6820         return ExprError();
6821       } else if (Complained)
6822         PrintInitLocationNote(S, Entity);
6823       break;
6824     }
6825 
6826     case SK_StringInit: {
6827       QualType Ty = Step->Type;
6828       CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty,
6829                       S.Context.getAsArrayType(Ty), S);
6830       break;
6831     }
6832 
6833     case SK_ObjCObjectConversion:
6834       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6835                           CK_ObjCObjectLValueCast,
6836                           CurInit.get()->getValueKind());
6837       break;
6838 
6839     case SK_ArrayInit:
6840       // Okay: we checked everything before creating this step. Note that
6841       // this is a GNU extension.
6842       S.Diag(Kind.getLocation(), diag::ext_array_init_copy)
6843         << Step->Type << CurInit.get()->getType()
6844         << CurInit.get()->getSourceRange();
6845 
6846       // If the destination type is an incomplete array type, update the
6847       // type accordingly.
6848       if (ResultType) {
6849         if (const IncompleteArrayType *IncompleteDest
6850                            = S.Context.getAsIncompleteArrayType(Step->Type)) {
6851           if (const ConstantArrayType *ConstantSource
6852                  = S.Context.getAsConstantArrayType(CurInit.get()->getType())) {
6853             *ResultType = S.Context.getConstantArrayType(
6854                                              IncompleteDest->getElementType(),
6855                                              ConstantSource->getSize(),
6856                                              ArrayType::Normal, 0);
6857           }
6858         }
6859       }
6860       break;
6861 
6862     case SK_ParenthesizedArrayInit:
6863       // Okay: we checked everything before creating this step. Note that
6864       // this is a GNU extension.
6865       S.Diag(Kind.getLocation(), diag::ext_array_init_parens)
6866         << CurInit.get()->getSourceRange();
6867       break;
6868 
6869     case SK_PassByIndirectCopyRestore:
6870     case SK_PassByIndirectRestore:
6871       checkIndirectCopyRestoreSource(S, CurInit.get());
6872       CurInit = new (S.Context) ObjCIndirectCopyRestoreExpr(
6873           CurInit.get(), Step->Type,
6874           Step->Kind == SK_PassByIndirectCopyRestore);
6875       break;
6876 
6877     case SK_ProduceObjCObject:
6878       CurInit =
6879           ImplicitCastExpr::Create(S.Context, Step->Type, CK_ARCProduceObject,
6880                                    CurInit.get(), nullptr, VK_RValue);
6881       break;
6882 
6883     case SK_StdInitializerList: {
6884       S.Diag(CurInit.get()->getExprLoc(),
6885              diag::warn_cxx98_compat_initializer_list_init)
6886         << CurInit.get()->getSourceRange();
6887 
6888       // Materialize the temporary into memory.
6889       MaterializeTemporaryExpr *MTE = S.CreateMaterializeTemporaryExpr(
6890           CurInit.get()->getType(), CurInit.get(),
6891           /*BoundToLvalueReference=*/false);
6892 
6893       // Maybe lifetime-extend the array temporary's subobjects to match the
6894       // entity's lifetime.
6895       if (const InitializedEntity *ExtendingEntity =
6896               getEntityForTemporaryLifetimeExtension(&Entity))
6897         if (performReferenceExtension(MTE, ExtendingEntity))
6898           warnOnLifetimeExtension(S, Entity, CurInit.get(),
6899                                   /*IsInitializerList=*/true,
6900                                   ExtendingEntity->getDecl());
6901 
6902       // Wrap it in a construction of a std::initializer_list<T>.
6903       CurInit = new (S.Context) CXXStdInitializerListExpr(Step->Type, MTE);
6904 
6905       // Bind the result, in case the library has given initializer_list a
6906       // non-trivial destructor.
6907       if (shouldBindAsTemporary(Entity))
6908         CurInit = S.MaybeBindToTemporary(CurInit.get());
6909       break;
6910     }
6911 
6912     case SK_OCLSamplerInit: {
6913       // Sampler initialzation have 5 cases:
6914       //   1. function argument passing
6915       //      1a. argument is a file-scope variable
6916       //      1b. argument is a function-scope variable
6917       //      1c. argument is one of caller function's parameters
6918       //   2. variable initialization
6919       //      2a. initializing a file-scope variable
6920       //      2b. initializing a function-scope variable
6921       //
6922       // For file-scope variables, since they cannot be initialized by function
6923       // call of __translate_sampler_initializer in LLVM IR, their references
6924       // need to be replaced by a cast from their literal initializers to
6925       // sampler type. Since sampler variables can only be used in function
6926       // calls as arguments, we only need to replace them when handling the
6927       // argument passing.
6928       assert(Step->Type->isSamplerT() &&
6929              "Sampler initialization on non-sampler type.");
6930       Expr *Init = CurInit.get();
6931       QualType SourceType = Init->getType();
6932       // Case 1
6933       if (Entity.isParameterKind()) {
6934         if (!SourceType->isSamplerT()) {
6935           S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
6936             << SourceType;
6937           break;
6938         } else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init)) {
6939           auto Var = cast<VarDecl>(DRE->getDecl());
6940           // Case 1b and 1c
6941           // No cast from integer to sampler is needed.
6942           if (!Var->hasGlobalStorage()) {
6943             CurInit = ImplicitCastExpr::Create(S.Context, Step->Type,
6944                                                CK_LValueToRValue, Init,
6945                                                /*BasePath=*/nullptr, VK_RValue);
6946             break;
6947           }
6948           // Case 1a
6949           // For function call with a file-scope sampler variable as argument,
6950           // get the integer literal.
6951           // Do not diagnose if the file-scope variable does not have initializer
6952           // since this has already been diagnosed when parsing the variable
6953           // declaration.
6954           if (!Var->getInit() || !isa<ImplicitCastExpr>(Var->getInit()))
6955             break;
6956           Init = cast<ImplicitCastExpr>(const_cast<Expr*>(
6957             Var->getInit()))->getSubExpr();
6958           SourceType = Init->getType();
6959         }
6960       } else {
6961         // Case 2
6962         // Check initializer is 32 bit integer constant.
6963         // If the initializer is taken from global variable, do not diagnose since
6964         // this has already been done when parsing the variable declaration.
6965         if (!Init->isConstantInitializer(S.Context, false))
6966           break;
6967 
6968         if (!SourceType->isIntegerType() ||
6969             32 != S.Context.getIntWidth(SourceType)) {
6970           S.Diag(Kind.getLocation(), diag::err_sampler_initializer_not_integer)
6971             << SourceType;
6972           break;
6973         }
6974 
6975         llvm::APSInt Result;
6976         Init->EvaluateAsInt(Result, S.Context);
6977         const uint64_t SamplerValue = Result.getLimitedValue();
6978         // 32-bit value of sampler's initializer is interpreted as
6979         // bit-field with the following structure:
6980         // |unspecified|Filter|Addressing Mode| Normalized Coords|
6981         // |31        6|5    4|3             1|                 0|
6982         // This structure corresponds to enum values of sampler properties
6983         // defined in SPIR spec v1.2 and also opencl-c.h
6984         unsigned AddressingMode  = (0x0E & SamplerValue) >> 1;
6985         unsigned FilterMode      = (0x30 & SamplerValue) >> 4;
6986         if (FilterMode != 1 && FilterMode != 2)
6987           S.Diag(Kind.getLocation(),
6988                  diag::warn_sampler_initializer_invalid_bits)
6989                  << "Filter Mode";
6990         if (AddressingMode > 4)
6991           S.Diag(Kind.getLocation(),
6992                  diag::warn_sampler_initializer_invalid_bits)
6993                  << "Addressing Mode";
6994       }
6995 
6996       // Cases 1a, 2a and 2b
6997       // Insert cast from integer to sampler.
6998       CurInit = S.ImpCastExprToType(Init, S.Context.OCLSamplerTy,
6999                                       CK_IntToOCLSampler);
7000       break;
7001     }
7002     case SK_OCLZeroEvent: {
7003       assert(Step->Type->isEventT() &&
7004              "Event initialization on non-event type.");
7005 
7006       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
7007                                     CK_ZeroToOCLEvent,
7008                                     CurInit.get()->getValueKind());
7009       break;
7010     }
7011     }
7012   }
7013 
7014   // Diagnose non-fatal problems with the completed initialization.
7015   if (Entity.getKind() == InitializedEntity::EK_Member &&
7016       cast<FieldDecl>(Entity.getDecl())->isBitField())
7017     S.CheckBitFieldInitialization(Kind.getLocation(),
7018                                   cast<FieldDecl>(Entity.getDecl()),
7019                                   CurInit.get());
7020 
7021   // Check for std::move on construction.
7022   if (const Expr *E = CurInit.get()) {
7023     CheckMoveOnConstruction(S, E,
7024                             Entity.getKind() == InitializedEntity::EK_Result);
7025   }
7026 
7027   return CurInit;
7028 }
7029 
7030 /// Somewhere within T there is an uninitialized reference subobject.
7031 /// Dig it out and diagnose it.
7032 static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc,
7033                                            QualType T) {
7034   if (T->isReferenceType()) {
7035     S.Diag(Loc, diag::err_reference_without_init)
7036       << T.getNonReferenceType();
7037     return true;
7038   }
7039 
7040   CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
7041   if (!RD || !RD->hasUninitializedReferenceMember())
7042     return false;
7043 
7044   for (const auto *FI : RD->fields()) {
7045     if (FI->isUnnamedBitfield())
7046       continue;
7047 
7048     if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {
7049       S.Diag(Loc, diag::note_value_initialization_here) << RD;
7050       return true;
7051     }
7052   }
7053 
7054   for (const auto &BI : RD->bases()) {
7055     if (DiagnoseUninitializedReference(S, BI.getLocStart(), BI.getType())) {
7056       S.Diag(Loc, diag::note_value_initialization_here) << RD;
7057       return true;
7058     }
7059   }
7060 
7061   return false;
7062 }
7063 
7064 
7065 //===----------------------------------------------------------------------===//
7066 // Diagnose initialization failures
7067 //===----------------------------------------------------------------------===//
7068 
7069 /// Emit notes associated with an initialization that failed due to a
7070 /// "simple" conversion failure.
7071 static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity,
7072                                    Expr *op) {
7073   QualType destType = entity.getType();
7074   if (destType.getNonReferenceType()->isObjCObjectPointerType() &&
7075       op->getType()->isObjCObjectPointerType()) {
7076 
7077     // Emit a possible note about the conversion failing because the
7078     // operand is a message send with a related result type.
7079     S.EmitRelatedResultTypeNote(op);
7080 
7081     // Emit a possible note about a return failing because we're
7082     // expecting a related result type.
7083     if (entity.getKind() == InitializedEntity::EK_Result)
7084       S.EmitRelatedResultTypeNoteForReturn(destType);
7085   }
7086 }
7087 
7088 static void diagnoseListInit(Sema &S, const InitializedEntity &Entity,
7089                              InitListExpr *InitList) {
7090   QualType DestType = Entity.getType();
7091 
7092   QualType E;
7093   if (S.getLangOpts().CPlusPlus11 && S.isStdInitializerList(DestType, &E)) {
7094     QualType ArrayType = S.Context.getConstantArrayType(
7095         E.withConst(),
7096         llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
7097                     InitList->getNumInits()),
7098         clang::ArrayType::Normal, 0);
7099     InitializedEntity HiddenArray =
7100         InitializedEntity::InitializeTemporary(ArrayType);
7101     return diagnoseListInit(S, HiddenArray, InitList);
7102   }
7103 
7104   if (DestType->isReferenceType()) {
7105     // A list-initialization failure for a reference means that we tried to
7106     // create a temporary of the inner type (per [dcl.init.list]p3.6) and the
7107     // inner initialization failed.
7108     QualType T = DestType->getAs<ReferenceType>()->getPointeeType();
7109     diagnoseListInit(S, InitializedEntity::InitializeTemporary(T), InitList);
7110     SourceLocation Loc = InitList->getLocStart();
7111     if (auto *D = Entity.getDecl())
7112       Loc = D->getLocation();
7113     S.Diag(Loc, diag::note_in_reference_temporary_list_initializer) << T;
7114     return;
7115   }
7116 
7117   InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
7118                                    /*VerifyOnly=*/false,
7119                                    /*TreatUnavailableAsInvalid=*/false);
7120   assert(DiagnoseInitList.HadError() &&
7121          "Inconsistent init list check result.");
7122 }
7123 
7124 bool InitializationSequence::Diagnose(Sema &S,
7125                                       const InitializedEntity &Entity,
7126                                       const InitializationKind &Kind,
7127                                       ArrayRef<Expr *> Args) {
7128   if (!Failed())
7129     return false;
7130 
7131   QualType DestType = Entity.getType();
7132   switch (Failure) {
7133   case FK_TooManyInitsForReference:
7134     // FIXME: Customize for the initialized entity?
7135     if (Args.empty()) {
7136       // Dig out the reference subobject which is uninitialized and diagnose it.
7137       // If this is value-initialization, this could be nested some way within
7138       // the target type.
7139       assert(Kind.getKind() == InitializationKind::IK_Value ||
7140              DestType->isReferenceType());
7141       bool Diagnosed =
7142         DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
7143       assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
7144       (void)Diagnosed;
7145     } else  // FIXME: diagnostic below could be better!
7146       S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
7147         << SourceRange(Args.front()->getLocStart(), Args.back()->getLocEnd());
7148     break;
7149 
7150   case FK_ArrayNeedsInitList:
7151     S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
7152     break;
7153   case FK_ArrayNeedsInitListOrStringLiteral:
7154     S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
7155     break;
7156   case FK_ArrayNeedsInitListOrWideStringLiteral:
7157     S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
7158     break;
7159   case FK_NarrowStringIntoWideCharArray:
7160     S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
7161     break;
7162   case FK_WideStringIntoCharArray:
7163     S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
7164     break;
7165   case FK_IncompatWideStringIntoWideChar:
7166     S.Diag(Kind.getLocation(),
7167            diag::err_array_init_incompat_wide_string_into_wchar);
7168     break;
7169   case FK_ArrayTypeMismatch:
7170   case FK_NonConstantArrayInit:
7171     S.Diag(Kind.getLocation(),
7172            (Failure == FK_ArrayTypeMismatch
7173               ? diag::err_array_init_different_type
7174               : diag::err_array_init_non_constant_array))
7175       << DestType.getNonReferenceType()
7176       << Args[0]->getType()
7177       << Args[0]->getSourceRange();
7178     break;
7179 
7180   case FK_VariableLengthArrayHasInitializer:
7181     S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
7182       << Args[0]->getSourceRange();
7183     break;
7184 
7185   case FK_AddressOfOverloadFailed: {
7186     DeclAccessPair Found;
7187     S.ResolveAddressOfOverloadedFunction(Args[0],
7188                                          DestType.getNonReferenceType(),
7189                                          true,
7190                                          Found);
7191     break;
7192   }
7193 
7194   case FK_AddressOfUnaddressableFunction: {
7195     auto *FD = cast<FunctionDecl>(cast<DeclRefExpr>(Args[0])->getDecl());
7196     S.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
7197                                         Args[0]->getLocStart());
7198     break;
7199   }
7200 
7201   case FK_ReferenceInitOverloadFailed:
7202   case FK_UserConversionOverloadFailed:
7203     switch (FailedOverloadResult) {
7204     case OR_Ambiguous:
7205       if (Failure == FK_UserConversionOverloadFailed)
7206         S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
7207           << Args[0]->getType() << DestType
7208           << Args[0]->getSourceRange();
7209       else
7210         S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
7211           << DestType << Args[0]->getType()
7212           << Args[0]->getSourceRange();
7213 
7214       FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
7215       break;
7216 
7217     case OR_No_Viable_Function:
7218       if (!S.RequireCompleteType(Kind.getLocation(),
7219                                  DestType.getNonReferenceType(),
7220                           diag::err_typecheck_nonviable_condition_incomplete,
7221                                Args[0]->getType(), Args[0]->getSourceRange()))
7222         S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
7223           << (Entity.getKind() == InitializedEntity::EK_Result)
7224           << Args[0]->getType() << Args[0]->getSourceRange()
7225           << DestType.getNonReferenceType();
7226 
7227       FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
7228       break;
7229 
7230     case OR_Deleted: {
7231       S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
7232         << Args[0]->getType() << DestType.getNonReferenceType()
7233         << Args[0]->getSourceRange();
7234       OverloadCandidateSet::iterator Best;
7235       OverloadingResult Ovl
7236         = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best,
7237                                                 true);
7238       if (Ovl == OR_Deleted) {
7239         S.NoteDeletedFunction(Best->Function);
7240       } else {
7241         llvm_unreachable("Inconsistent overload resolution?");
7242       }
7243       break;
7244     }
7245 
7246     case OR_Success:
7247       llvm_unreachable("Conversion did not fail!");
7248     }
7249     break;
7250 
7251   case FK_NonConstLValueReferenceBindingToTemporary:
7252     if (isa<InitListExpr>(Args[0])) {
7253       S.Diag(Kind.getLocation(),
7254              diag::err_lvalue_reference_bind_to_initlist)
7255       << DestType.getNonReferenceType().isVolatileQualified()
7256       << DestType.getNonReferenceType()
7257       << Args[0]->getSourceRange();
7258       break;
7259     }
7260     // Intentional fallthrough
7261 
7262   case FK_NonConstLValueReferenceBindingToUnrelated:
7263     S.Diag(Kind.getLocation(),
7264            Failure == FK_NonConstLValueReferenceBindingToTemporary
7265              ? diag::err_lvalue_reference_bind_to_temporary
7266              : diag::err_lvalue_reference_bind_to_unrelated)
7267       << DestType.getNonReferenceType().isVolatileQualified()
7268       << DestType.getNonReferenceType()
7269       << Args[0]->getType()
7270       << Args[0]->getSourceRange();
7271     break;
7272 
7273   case FK_RValueReferenceBindingToLValue:
7274     S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
7275       << DestType.getNonReferenceType() << Args[0]->getType()
7276       << Args[0]->getSourceRange();
7277     break;
7278 
7279   case FK_ReferenceInitDropsQualifiers: {
7280     QualType SourceType = Args[0]->getType();
7281     QualType NonRefType = DestType.getNonReferenceType();
7282     Qualifiers DroppedQualifiers =
7283         SourceType.getQualifiers() - NonRefType.getQualifiers();
7284 
7285     S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
7286       << SourceType
7287       << NonRefType
7288       << DroppedQualifiers.getCVRQualifiers()
7289       << Args[0]->getSourceRange();
7290     break;
7291   }
7292 
7293   case FK_ReferenceInitFailed:
7294     S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
7295       << DestType.getNonReferenceType()
7296       << Args[0]->isLValue()
7297       << Args[0]->getType()
7298       << Args[0]->getSourceRange();
7299     emitBadConversionNotes(S, Entity, Args[0]);
7300     break;
7301 
7302   case FK_ConversionFailed: {
7303     QualType FromType = Args[0]->getType();
7304     PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
7305       << (int)Entity.getKind()
7306       << DestType
7307       << Args[0]->isLValue()
7308       << FromType
7309       << Args[0]->getSourceRange();
7310     S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
7311     S.Diag(Kind.getLocation(), PDiag);
7312     emitBadConversionNotes(S, Entity, Args[0]);
7313     break;
7314   }
7315 
7316   case FK_ConversionFromPropertyFailed:
7317     // No-op. This error has already been reported.
7318     break;
7319 
7320   case FK_TooManyInitsForScalar: {
7321     SourceRange R;
7322 
7323     auto *InitList = dyn_cast<InitListExpr>(Args[0]);
7324     if (InitList && InitList->getNumInits() >= 1) {
7325       R = SourceRange(InitList->getInit(0)->getLocEnd(), InitList->getLocEnd());
7326     } else {
7327       assert(Args.size() > 1 && "Expected multiple initializers!");
7328       R = SourceRange(Args.front()->getLocEnd(), Args.back()->getLocEnd());
7329     }
7330 
7331     R.setBegin(S.getLocForEndOfToken(R.getBegin()));
7332     if (Kind.isCStyleOrFunctionalCast())
7333       S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
7334         << R;
7335     else
7336       S.Diag(Kind.getLocation(), diag::err_excess_initializers)
7337         << /*scalar=*/2 << R;
7338     break;
7339   }
7340 
7341   case FK_ReferenceBindingToInitList:
7342     S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
7343       << DestType.getNonReferenceType() << Args[0]->getSourceRange();
7344     break;
7345 
7346   case FK_InitListBadDestinationType:
7347     S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
7348       << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
7349     break;
7350 
7351   case FK_ListConstructorOverloadFailed:
7352   case FK_ConstructorOverloadFailed: {
7353     SourceRange ArgsRange;
7354     if (Args.size())
7355       ArgsRange = SourceRange(Args.front()->getLocStart(),
7356                               Args.back()->getLocEnd());
7357 
7358     if (Failure == FK_ListConstructorOverloadFailed) {
7359       assert(Args.size() == 1 &&
7360              "List construction from other than 1 argument.");
7361       InitListExpr *InitList = cast<InitListExpr>(Args[0]);
7362       Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
7363     }
7364 
7365     // FIXME: Using "DestType" for the entity we're printing is probably
7366     // bad.
7367     switch (FailedOverloadResult) {
7368       case OR_Ambiguous:
7369         S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
7370           << DestType << ArgsRange;
7371         FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
7372         break;
7373 
7374       case OR_No_Viable_Function:
7375         if (Kind.getKind() == InitializationKind::IK_Default &&
7376             (Entity.getKind() == InitializedEntity::EK_Base ||
7377              Entity.getKind() == InitializedEntity::EK_Member) &&
7378             isa<CXXConstructorDecl>(S.CurContext)) {
7379           // This is implicit default initialization of a member or
7380           // base within a constructor. If no viable function was
7381           // found, notify the user that they need to explicitly
7382           // initialize this base/member.
7383           CXXConstructorDecl *Constructor
7384             = cast<CXXConstructorDecl>(S.CurContext);
7385           const CXXRecordDecl *InheritedFrom = nullptr;
7386           if (auto Inherited = Constructor->getInheritedConstructor())
7387             InheritedFrom = Inherited.getShadowDecl()->getNominatedBaseClass();
7388           if (Entity.getKind() == InitializedEntity::EK_Base) {
7389             S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
7390               << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
7391               << S.Context.getTypeDeclType(Constructor->getParent())
7392               << /*base=*/0
7393               << Entity.getType()
7394               << InheritedFrom;
7395 
7396             RecordDecl *BaseDecl
7397               = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
7398                                                                   ->getDecl();
7399             S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
7400               << S.Context.getTagDeclType(BaseDecl);
7401           } else {
7402             S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
7403               << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
7404               << S.Context.getTypeDeclType(Constructor->getParent())
7405               << /*member=*/1
7406               << Entity.getName()
7407               << InheritedFrom;
7408             S.Diag(Entity.getDecl()->getLocation(),
7409                    diag::note_member_declared_at);
7410 
7411             if (const RecordType *Record
7412                                  = Entity.getType()->getAs<RecordType>())
7413               S.Diag(Record->getDecl()->getLocation(),
7414                      diag::note_previous_decl)
7415                 << S.Context.getTagDeclType(Record->getDecl());
7416           }
7417           break;
7418         }
7419 
7420         S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
7421           << DestType << ArgsRange;
7422         FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
7423         break;
7424 
7425       case OR_Deleted: {
7426         OverloadCandidateSet::iterator Best;
7427         OverloadingResult Ovl
7428           = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
7429         if (Ovl != OR_Deleted) {
7430           S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
7431             << true << DestType << ArgsRange;
7432           llvm_unreachable("Inconsistent overload resolution?");
7433           break;
7434         }
7435 
7436         // If this is a defaulted or implicitly-declared function, then
7437         // it was implicitly deleted. Make it clear that the deletion was
7438         // implicit.
7439         if (S.isImplicitlyDeleted(Best->Function))
7440           S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
7441             << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
7442             << DestType << ArgsRange;
7443         else
7444           S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
7445             << true << DestType << ArgsRange;
7446 
7447         S.NoteDeletedFunction(Best->Function);
7448         break;
7449       }
7450 
7451       case OR_Success:
7452         llvm_unreachable("Conversion did not fail!");
7453     }
7454   }
7455   break;
7456 
7457   case FK_DefaultInitOfConst:
7458     if (Entity.getKind() == InitializedEntity::EK_Member &&
7459         isa<CXXConstructorDecl>(S.CurContext)) {
7460       // This is implicit default-initialization of a const member in
7461       // a constructor. Complain that it needs to be explicitly
7462       // initialized.
7463       CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
7464       S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
7465         << (Constructor->getInheritedConstructor() ? 2 :
7466             Constructor->isImplicit() ? 1 : 0)
7467         << S.Context.getTypeDeclType(Constructor->getParent())
7468         << /*const=*/1
7469         << Entity.getName();
7470       S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
7471         << Entity.getName();
7472     } else {
7473       S.Diag(Kind.getLocation(), diag::err_default_init_const)
7474           << DestType << (bool)DestType->getAs<RecordType>();
7475     }
7476     break;
7477 
7478   case FK_Incomplete:
7479     S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
7480                           diag::err_init_incomplete_type);
7481     break;
7482 
7483   case FK_ListInitializationFailed: {
7484     // Run the init list checker again to emit diagnostics.
7485     InitListExpr *InitList = cast<InitListExpr>(Args[0]);
7486     diagnoseListInit(S, Entity, InitList);
7487     break;
7488   }
7489 
7490   case FK_PlaceholderType: {
7491     // FIXME: Already diagnosed!
7492     break;
7493   }
7494 
7495   case FK_ExplicitConstructor: {
7496     S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
7497       << Args[0]->getSourceRange();
7498     OverloadCandidateSet::iterator Best;
7499     OverloadingResult Ovl
7500       = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
7501     (void)Ovl;
7502     assert(Ovl == OR_Success && "Inconsistent overload resolution");
7503     CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
7504     S.Diag(CtorDecl->getLocation(), diag::note_constructor_declared_here);
7505     break;
7506   }
7507   }
7508 
7509   PrintInitLocationNote(S, Entity);
7510   return true;
7511 }
7512 
7513 void InitializationSequence::dump(raw_ostream &OS) const {
7514   switch (SequenceKind) {
7515   case FailedSequence: {
7516     OS << "Failed sequence: ";
7517     switch (Failure) {
7518     case FK_TooManyInitsForReference:
7519       OS << "too many initializers for reference";
7520       break;
7521 
7522     case FK_ArrayNeedsInitList:
7523       OS << "array requires initializer list";
7524       break;
7525 
7526     case FK_AddressOfUnaddressableFunction:
7527       OS << "address of unaddressable function was taken";
7528       break;
7529 
7530     case FK_ArrayNeedsInitListOrStringLiteral:
7531       OS << "array requires initializer list or string literal";
7532       break;
7533 
7534     case FK_ArrayNeedsInitListOrWideStringLiteral:
7535       OS << "array requires initializer list or wide string literal";
7536       break;
7537 
7538     case FK_NarrowStringIntoWideCharArray:
7539       OS << "narrow string into wide char array";
7540       break;
7541 
7542     case FK_WideStringIntoCharArray:
7543       OS << "wide string into char array";
7544       break;
7545 
7546     case FK_IncompatWideStringIntoWideChar:
7547       OS << "incompatible wide string into wide char array";
7548       break;
7549 
7550     case FK_ArrayTypeMismatch:
7551       OS << "array type mismatch";
7552       break;
7553 
7554     case FK_NonConstantArrayInit:
7555       OS << "non-constant array initializer";
7556       break;
7557 
7558     case FK_AddressOfOverloadFailed:
7559       OS << "address of overloaded function failed";
7560       break;
7561 
7562     case FK_ReferenceInitOverloadFailed:
7563       OS << "overload resolution for reference initialization failed";
7564       break;
7565 
7566     case FK_NonConstLValueReferenceBindingToTemporary:
7567       OS << "non-const lvalue reference bound to temporary";
7568       break;
7569 
7570     case FK_NonConstLValueReferenceBindingToUnrelated:
7571       OS << "non-const lvalue reference bound to unrelated type";
7572       break;
7573 
7574     case FK_RValueReferenceBindingToLValue:
7575       OS << "rvalue reference bound to an lvalue";
7576       break;
7577 
7578     case FK_ReferenceInitDropsQualifiers:
7579       OS << "reference initialization drops qualifiers";
7580       break;
7581 
7582     case FK_ReferenceInitFailed:
7583       OS << "reference initialization failed";
7584       break;
7585 
7586     case FK_ConversionFailed:
7587       OS << "conversion failed";
7588       break;
7589 
7590     case FK_ConversionFromPropertyFailed:
7591       OS << "conversion from property failed";
7592       break;
7593 
7594     case FK_TooManyInitsForScalar:
7595       OS << "too many initializers for scalar";
7596       break;
7597 
7598     case FK_ReferenceBindingToInitList:
7599       OS << "referencing binding to initializer list";
7600       break;
7601 
7602     case FK_InitListBadDestinationType:
7603       OS << "initializer list for non-aggregate, non-scalar type";
7604       break;
7605 
7606     case FK_UserConversionOverloadFailed:
7607       OS << "overloading failed for user-defined conversion";
7608       break;
7609 
7610     case FK_ConstructorOverloadFailed:
7611       OS << "constructor overloading failed";
7612       break;
7613 
7614     case FK_DefaultInitOfConst:
7615       OS << "default initialization of a const variable";
7616       break;
7617 
7618     case FK_Incomplete:
7619       OS << "initialization of incomplete type";
7620       break;
7621 
7622     case FK_ListInitializationFailed:
7623       OS << "list initialization checker failure";
7624       break;
7625 
7626     case FK_VariableLengthArrayHasInitializer:
7627       OS << "variable length array has an initializer";
7628       break;
7629 
7630     case FK_PlaceholderType:
7631       OS << "initializer expression isn't contextually valid";
7632       break;
7633 
7634     case FK_ListConstructorOverloadFailed:
7635       OS << "list constructor overloading failed";
7636       break;
7637 
7638     case FK_ExplicitConstructor:
7639       OS << "list copy initialization chose explicit constructor";
7640       break;
7641     }
7642     OS << '\n';
7643     return;
7644   }
7645 
7646   case DependentSequence:
7647     OS << "Dependent sequence\n";
7648     return;
7649 
7650   case NormalSequence:
7651     OS << "Normal sequence: ";
7652     break;
7653   }
7654 
7655   for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
7656     if (S != step_begin()) {
7657       OS << " -> ";
7658     }
7659 
7660     switch (S->Kind) {
7661     case SK_ResolveAddressOfOverloadedFunction:
7662       OS << "resolve address of overloaded function";
7663       break;
7664 
7665     case SK_CastDerivedToBaseRValue:
7666       OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")";
7667       break;
7668 
7669     case SK_CastDerivedToBaseXValue:
7670       OS << "derived-to-base case (xvalue" << S->Type.getAsString() << ")";
7671       break;
7672 
7673     case SK_CastDerivedToBaseLValue:
7674       OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")";
7675       break;
7676 
7677     case SK_BindReference:
7678       OS << "bind reference to lvalue";
7679       break;
7680 
7681     case SK_BindReferenceToTemporary:
7682       OS << "bind reference to a temporary";
7683       break;
7684 
7685     case SK_ExtraneousCopyToTemporary:
7686       OS << "extraneous C++03 copy to temporary";
7687       break;
7688 
7689     case SK_UserConversion:
7690       OS << "user-defined conversion via " << *S->Function.Function;
7691       break;
7692 
7693     case SK_QualificationConversionRValue:
7694       OS << "qualification conversion (rvalue)";
7695       break;
7696 
7697     case SK_QualificationConversionXValue:
7698       OS << "qualification conversion (xvalue)";
7699       break;
7700 
7701     case SK_QualificationConversionLValue:
7702       OS << "qualification conversion (lvalue)";
7703       break;
7704 
7705     case SK_AtomicConversion:
7706       OS << "non-atomic-to-atomic conversion";
7707       break;
7708 
7709     case SK_LValueToRValue:
7710       OS << "load (lvalue to rvalue)";
7711       break;
7712 
7713     case SK_ConversionSequence:
7714       OS << "implicit conversion sequence (";
7715       S->ICS->dump(); // FIXME: use OS
7716       OS << ")";
7717       break;
7718 
7719     case SK_ConversionSequenceNoNarrowing:
7720       OS << "implicit conversion sequence with narrowing prohibited (";
7721       S->ICS->dump(); // FIXME: use OS
7722       OS << ")";
7723       break;
7724 
7725     case SK_ListInitialization:
7726       OS << "list aggregate initialization";
7727       break;
7728 
7729     case SK_UnwrapInitList:
7730       OS << "unwrap reference initializer list";
7731       break;
7732 
7733     case SK_RewrapInitList:
7734       OS << "rewrap reference initializer list";
7735       break;
7736 
7737     case SK_ConstructorInitialization:
7738       OS << "constructor initialization";
7739       break;
7740 
7741     case SK_ConstructorInitializationFromList:
7742       OS << "list initialization via constructor";
7743       break;
7744 
7745     case SK_ZeroInitialization:
7746       OS << "zero initialization";
7747       break;
7748 
7749     case SK_CAssignment:
7750       OS << "C assignment";
7751       break;
7752 
7753     case SK_StringInit:
7754       OS << "string initialization";
7755       break;
7756 
7757     case SK_ObjCObjectConversion:
7758       OS << "Objective-C object conversion";
7759       break;
7760 
7761     case SK_ArrayInit:
7762       OS << "array initialization";
7763       break;
7764 
7765     case SK_ParenthesizedArrayInit:
7766       OS << "parenthesized array initialization";
7767       break;
7768 
7769     case SK_PassByIndirectCopyRestore:
7770       OS << "pass by indirect copy and restore";
7771       break;
7772 
7773     case SK_PassByIndirectRestore:
7774       OS << "pass by indirect restore";
7775       break;
7776 
7777     case SK_ProduceObjCObject:
7778       OS << "Objective-C object retension";
7779       break;
7780 
7781     case SK_StdInitializerList:
7782       OS << "std::initializer_list from initializer list";
7783       break;
7784 
7785     case SK_StdInitializerListConstructorCall:
7786       OS << "list initialization from std::initializer_list";
7787       break;
7788 
7789     case SK_OCLSamplerInit:
7790       OS << "OpenCL sampler_t from integer constant";
7791       break;
7792 
7793     case SK_OCLZeroEvent:
7794       OS << "OpenCL event_t from zero";
7795       break;
7796     }
7797 
7798     OS << " [" << S->Type.getAsString() << ']';
7799   }
7800 
7801   OS << '\n';
7802 }
7803 
7804 void InitializationSequence::dump() const {
7805   dump(llvm::errs());
7806 }
7807 
7808 static void DiagnoseNarrowingInInitList(Sema &S,
7809                                         const ImplicitConversionSequence &ICS,
7810                                         QualType PreNarrowingType,
7811                                         QualType EntityType,
7812                                         const Expr *PostInit) {
7813   const StandardConversionSequence *SCS = nullptr;
7814   switch (ICS.getKind()) {
7815   case ImplicitConversionSequence::StandardConversion:
7816     SCS = &ICS.Standard;
7817     break;
7818   case ImplicitConversionSequence::UserDefinedConversion:
7819     SCS = &ICS.UserDefined.After;
7820     break;
7821   case ImplicitConversionSequence::AmbiguousConversion:
7822   case ImplicitConversionSequence::EllipsisConversion:
7823   case ImplicitConversionSequence::BadConversion:
7824     return;
7825   }
7826 
7827   // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
7828   APValue ConstantValue;
7829   QualType ConstantType;
7830   switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
7831                                 ConstantType)) {
7832   case NK_Not_Narrowing:
7833     // No narrowing occurred.
7834     return;
7835 
7836   case NK_Type_Narrowing:
7837     // This was a floating-to-integer conversion, which is always considered a
7838     // narrowing conversion even if the value is a constant and can be
7839     // represented exactly as an integer.
7840     S.Diag(PostInit->getLocStart(),
7841            (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7842                ? diag::warn_init_list_type_narrowing
7843                : diag::ext_init_list_type_narrowing)
7844       << PostInit->getSourceRange()
7845       << PreNarrowingType.getLocalUnqualifiedType()
7846       << EntityType.getLocalUnqualifiedType();
7847     break;
7848 
7849   case NK_Constant_Narrowing:
7850     // A constant value was narrowed.
7851     S.Diag(PostInit->getLocStart(),
7852            (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7853                ? diag::warn_init_list_constant_narrowing
7854                : diag::ext_init_list_constant_narrowing)
7855       << PostInit->getSourceRange()
7856       << ConstantValue.getAsString(S.getASTContext(), ConstantType)
7857       << EntityType.getLocalUnqualifiedType();
7858     break;
7859 
7860   case NK_Variable_Narrowing:
7861     // A variable's value may have been narrowed.
7862     S.Diag(PostInit->getLocStart(),
7863            (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7864                ? diag::warn_init_list_variable_narrowing
7865                : diag::ext_init_list_variable_narrowing)
7866       << PostInit->getSourceRange()
7867       << PreNarrowingType.getLocalUnqualifiedType()
7868       << EntityType.getLocalUnqualifiedType();
7869     break;
7870   }
7871 
7872   SmallString<128> StaticCast;
7873   llvm::raw_svector_ostream OS(StaticCast);
7874   OS << "static_cast<";
7875   if (const TypedefType *TT = EntityType->getAs<TypedefType>()) {
7876     // It's important to use the typedef's name if there is one so that the
7877     // fixit doesn't break code using types like int64_t.
7878     //
7879     // FIXME: This will break if the typedef requires qualification.  But
7880     // getQualifiedNameAsString() includes non-machine-parsable components.
7881     OS << *TT->getDecl();
7882   } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>())
7883     OS << BT->getName(S.getLangOpts());
7884   else {
7885     // Oops, we didn't find the actual type of the variable.  Don't emit a fixit
7886     // with a broken cast.
7887     return;
7888   }
7889   OS << ">(";
7890   S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_silence)
7891       << PostInit->getSourceRange()
7892       << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str())
7893       << FixItHint::CreateInsertion(
7894              S.getLocForEndOfToken(PostInit->getLocEnd()), ")");
7895 }
7896 
7897 //===----------------------------------------------------------------------===//
7898 // Initialization helper functions
7899 //===----------------------------------------------------------------------===//
7900 bool
7901 Sema::CanPerformCopyInitialization(const InitializedEntity &Entity,
7902                                    ExprResult Init) {
7903   if (Init.isInvalid())
7904     return false;
7905 
7906   Expr *InitE = Init.get();
7907   assert(InitE && "No initialization expression");
7908 
7909   InitializationKind Kind
7910     = InitializationKind::CreateCopy(InitE->getLocStart(), SourceLocation());
7911   InitializationSequence Seq(*this, Entity, Kind, InitE);
7912   return !Seq.Failed();
7913 }
7914 
7915 ExprResult
7916 Sema::PerformCopyInitialization(const InitializedEntity &Entity,
7917                                 SourceLocation EqualLoc,
7918                                 ExprResult Init,
7919                                 bool TopLevelOfInitList,
7920                                 bool AllowExplicit) {
7921   if (Init.isInvalid())
7922     return ExprError();
7923 
7924   Expr *InitE = Init.get();
7925   assert(InitE && "No initialization expression?");
7926 
7927   if (EqualLoc.isInvalid())
7928     EqualLoc = InitE->getLocStart();
7929 
7930   InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
7931                                                            EqualLoc,
7932                                                            AllowExplicit);
7933   InitializationSequence Seq(*this, Entity, Kind, InitE, TopLevelOfInitList);
7934 
7935   ExprResult Result = Seq.Perform(*this, Entity, Kind, InitE);
7936 
7937   return Result;
7938 }
7939