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