clang  7.0.0svn
SemaInit.cpp
Go to the documentation of this file.
1 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements semantic analysis for initializers.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/DeclObjC.h"
16 #include "clang/AST/ExprCXX.h"
17 #include "clang/AST/ExprObjC.h"
18 #include "clang/AST/TypeLoc.h"
19 #include "clang/Basic/TargetInfo.h"
20 #include "clang/Sema/Designator.h"
22 #include "clang/Sema/Lookup.h"
24 #include "llvm/ADT/APInt.h"
25 #include "llvm/ADT/SmallString.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/raw_ostream.h"
28 
29 using namespace clang;
30 
31 //===----------------------------------------------------------------------===//
32 // Sema Initialization Checking
33 //===----------------------------------------------------------------------===//
34 
35 /// Check whether T is compatible with a wide character type (wchar_t,
36 /// char16_t or char32_t).
37 static bool IsWideCharCompatible(QualType T, ASTContext &Context) {
38  if (Context.typesAreCompatible(Context.getWideCharType(), T))
39  return true;
40  if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) {
41  return Context.typesAreCompatible(Context.Char16Ty, T) ||
42  Context.typesAreCompatible(Context.Char32Ty, T);
43  }
44  return false;
45 }
46 
55 };
56 
57 /// Check whether the array of type AT can be initialized by the Init
58 /// expression by means of string initialization. Returns SIF_None if so,
59 /// otherwise returns a StringInitFailureKind that describes why the
60 /// initialization would not work.
62  ASTContext &Context) {
63  if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
64  return SIF_Other;
65 
66  // See if this is a string literal or @encode.
67  Init = Init->IgnoreParens();
68 
69  // Handle @encode, which is a narrow string.
70  if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
71  return SIF_None;
72 
73  // Otherwise we can only handle string literals.
74  StringLiteral *SL = dyn_cast<StringLiteral>(Init);
75  if (!SL)
76  return SIF_Other;
77 
78  const QualType ElemTy =
79  Context.getCanonicalType(AT->getElementType()).getUnqualifiedType();
80 
81  switch (SL->getKind()) {
83  // char8_t array can be initialized with a UTF-8 string.
84  if (ElemTy->isChar8Type())
85  return SIF_None;
86  LLVM_FALLTHROUGH;
88  // char array can be initialized with a narrow string.
89  // Only allow char x[] = "foo"; not char x[] = L"foo";
90  if (ElemTy->isCharType())
91  return (SL->getKind() == StringLiteral::UTF8 &&
92  Context.getLangOpts().Char8)
94  : SIF_None;
95  if (ElemTy->isChar8Type())
97  if (IsWideCharCompatible(ElemTy, Context))
99  return SIF_Other;
100  // C99 6.7.8p15 (with correction from DR343), or C11 6.7.9p15:
101  // "An array with element type compatible with a qualified or unqualified
102  // version of wchar_t, char16_t, or char32_t may be initialized by a wide
103  // string literal with the corresponding encoding prefix (L, u, or U,
104  // respectively), optionally enclosed in braces.
106  if (Context.typesAreCompatible(Context.Char16Ty, ElemTy))
107  return SIF_None;
108  if (ElemTy->isCharType() || ElemTy->isChar8Type())
109  return SIF_WideStringIntoChar;
110  if (IsWideCharCompatible(ElemTy, Context))
112  return SIF_Other;
114  if (Context.typesAreCompatible(Context.Char32Ty, ElemTy))
115  return SIF_None;
116  if (ElemTy->isCharType() || ElemTy->isChar8Type())
117  return SIF_WideStringIntoChar;
118  if (IsWideCharCompatible(ElemTy, Context))
120  return SIF_Other;
121  case StringLiteral::Wide:
122  if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy))
123  return SIF_None;
124  if (ElemTy->isCharType() || ElemTy->isChar8Type())
125  return SIF_WideStringIntoChar;
126  if (IsWideCharCompatible(ElemTy, Context))
128  return SIF_Other;
129  }
130 
131  llvm_unreachable("missed a StringLiteral kind?");
132 }
133 
135  ASTContext &Context) {
136  const ArrayType *arrayType = Context.getAsArrayType(declType);
137  if (!arrayType)
138  return SIF_Other;
139  return IsStringInit(init, arrayType, Context);
140 }
141 
142 /// Update the type of a string literal, including any surrounding parentheses,
143 /// to match the type of the object which it is initializing.
144 static void updateStringLiteralType(Expr *E, QualType Ty) {
145  while (true) {
146  E->setType(Ty);
147  if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
148  break;
149  else if (ParenExpr *PE = dyn_cast<ParenExpr>(E))
150  E = PE->getSubExpr();
151  else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
152  E = UO->getSubExpr();
153  else if (GenericSelectionExpr *GSE = dyn_cast<GenericSelectionExpr>(E))
154  E = GSE->getResultExpr();
155  else
156  llvm_unreachable("unexpected expr in string literal init");
157  }
158 }
159 
160 static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,
161  Sema &S) {
162  // Get the length of the string as parsed.
163  auto *ConstantArrayTy =
164  cast<ConstantArrayType>(Str->getType()->getAsArrayTypeUnsafe());
165  uint64_t StrLength = ConstantArrayTy->getSize().getZExtValue();
166 
167  if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
168  // C99 6.7.8p14. We have an array of character type with unknown size
169  // being initialized to a string literal.
170  llvm::APInt ConstVal(32, StrLength);
171  // Return a new array type (C99 6.7.8p22).
172  DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
173  ConstVal,
174  ArrayType::Normal, 0);
175  updateStringLiteralType(Str, DeclT);
176  return;
177  }
178 
179  const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
180 
181  // We have an array of character type with known size. However,
182  // the size may be smaller or larger than the string we are initializing.
183  // FIXME: Avoid truncation for 64-bit length strings.
184  if (S.getLangOpts().CPlusPlus) {
185  if (StringLiteral *SL = dyn_cast<StringLiteral>(Str->IgnoreParens())) {
186  // For Pascal strings it's OK to strip off the terminating null character,
187  // so the example below is valid:
188  //
189  // unsigned char a[2] = "\pa";
190  if (SL->isPascal())
191  StrLength--;
192  }
193 
194  // [dcl.init.string]p2
195  if (StrLength > CAT->getSize().getZExtValue())
196  S.Diag(Str->getLocStart(),
197  diag::err_initializer_string_for_char_array_too_long)
198  << Str->getSourceRange();
199  } else {
200  // C99 6.7.8p14.
201  if (StrLength-1 > CAT->getSize().getZExtValue())
202  S.Diag(Str->getLocStart(),
203  diag::ext_initializer_string_for_char_array_too_long)
204  << Str->getSourceRange();
205  }
206 
207  // Set the type to the actual size that we are initializing. If we have
208  // something like:
209  // char x[1] = "foo";
210  // then this will set the string literal's type to char[1].
211  updateStringLiteralType(Str, DeclT);
212 }
213 
214 //===----------------------------------------------------------------------===//
215 // Semantic checking for initializer lists.
216 //===----------------------------------------------------------------------===//
217 
218 namespace {
219 
220 /// Semantic checking for initializer lists.
221 ///
222 /// The InitListChecker class contains a set of routines that each
223 /// handle the initialization of a certain kind of entity, e.g.,
224 /// arrays, vectors, struct/union types, scalars, etc. The
225 /// InitListChecker itself performs a recursive walk of the subobject
226 /// structure of the type to be initialized, while stepping through
227 /// the initializer list one element at a time. The IList and Index
228 /// parameters to each of the Check* routines contain the active
229 /// (syntactic) initializer list and the index into that initializer
230 /// list that represents the current initializer. Each routine is
231 /// responsible for moving that Index forward as it consumes elements.
232 ///
233 /// Each Check* routine also has a StructuredList/StructuredIndex
234 /// arguments, which contains the current "structured" (semantic)
235 /// initializer list and the index into that initializer list where we
236 /// are copying initializers as we map them over to the semantic
237 /// list. Once we have completed our recursive walk of the subobject
238 /// structure, we will have constructed a full semantic initializer
239 /// list.
240 ///
241 /// C99 designators cause changes in the initializer list traversal,
242 /// because they make the initialization "jump" into a specific
243 /// subobject and then continue the initialization from that
244 /// point. CheckDesignatedInitializer() recursively steps into the
245 /// designated subobject and manages backing out the recursion to
246 /// initialize the subobjects after the one designated.
247 class InitListChecker {
248  Sema &SemaRef;
249  bool hadError;
250  bool VerifyOnly; // no diagnostics, no structure building
251  bool TreatUnavailableAsInvalid; // Used only in VerifyOnly mode.
252  llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic;
253  InitListExpr *FullyStructuredList;
254 
255  void CheckImplicitInitList(const InitializedEntity &Entity,
256  InitListExpr *ParentIList, QualType T,
257  unsigned &Index, InitListExpr *StructuredList,
258  unsigned &StructuredIndex);
259  void CheckExplicitInitList(const InitializedEntity &Entity,
260  InitListExpr *IList, QualType &T,
261  InitListExpr *StructuredList,
262  bool TopLevelObject = false);
263  void CheckListElementTypes(const InitializedEntity &Entity,
264  InitListExpr *IList, QualType &DeclType,
265  bool SubobjectIsDesignatorContext,
266  unsigned &Index,
267  InitListExpr *StructuredList,
268  unsigned &StructuredIndex,
269  bool TopLevelObject = false);
270  void CheckSubElementType(const InitializedEntity &Entity,
271  InitListExpr *IList, QualType ElemType,
272  unsigned &Index,
273  InitListExpr *StructuredList,
274  unsigned &StructuredIndex);
275  void CheckComplexType(const InitializedEntity &Entity,
276  InitListExpr *IList, QualType DeclType,
277  unsigned &Index,
278  InitListExpr *StructuredList,
279  unsigned &StructuredIndex);
280  void CheckScalarType(const InitializedEntity &Entity,
281  InitListExpr *IList, QualType DeclType,
282  unsigned &Index,
283  InitListExpr *StructuredList,
284  unsigned &StructuredIndex);
285  void CheckReferenceType(const InitializedEntity &Entity,
286  InitListExpr *IList, QualType DeclType,
287  unsigned &Index,
288  InitListExpr *StructuredList,
289  unsigned &StructuredIndex);
290  void CheckVectorType(const InitializedEntity &Entity,
291  InitListExpr *IList, QualType DeclType, unsigned &Index,
292  InitListExpr *StructuredList,
293  unsigned &StructuredIndex);
294  void CheckStructUnionTypes(const InitializedEntity &Entity,
295  InitListExpr *IList, QualType DeclType,
298  bool SubobjectIsDesignatorContext, unsigned &Index,
299  InitListExpr *StructuredList,
300  unsigned &StructuredIndex,
301  bool TopLevelObject = false);
302  void CheckArrayType(const InitializedEntity &Entity,
303  InitListExpr *IList, QualType &DeclType,
304  llvm::APSInt elementIndex,
305  bool SubobjectIsDesignatorContext, unsigned &Index,
306  InitListExpr *StructuredList,
307  unsigned &StructuredIndex);
308  bool CheckDesignatedInitializer(const InitializedEntity &Entity,
309  InitListExpr *IList, DesignatedInitExpr *DIE,
310  unsigned DesigIdx,
311  QualType &CurrentObjectType,
312  RecordDecl::field_iterator *NextField,
313  llvm::APSInt *NextElementIndex,
314  unsigned &Index,
315  InitListExpr *StructuredList,
316  unsigned &StructuredIndex,
317  bool FinishSubobjectInit,
318  bool TopLevelObject);
319  InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
320  QualType CurrentObjectType,
321  InitListExpr *StructuredList,
322  unsigned StructuredIndex,
323  SourceRange InitRange,
324  bool IsFullyOverwritten = false);
325  void UpdateStructuredListElement(InitListExpr *StructuredList,
326  unsigned &StructuredIndex,
327  Expr *expr);
328  int numArrayElements(QualType DeclType);
329  int numStructUnionElements(QualType DeclType);
330 
331  static ExprResult PerformEmptyInit(Sema &SemaRef,
332  SourceLocation Loc,
333  const InitializedEntity &Entity,
334  bool VerifyOnly,
335  bool TreatUnavailableAsInvalid);
336 
337  // Explanation on the "FillWithNoInit" mode:
338  //
339  // Assume we have the following definitions (Case#1):
340  // struct P { char x[6][6]; } xp = { .x[1] = "bar" };
341  // struct PP { struct P lp; } l = { .lp = xp, .lp.x[1][2] = 'f' };
342  //
343  // l.lp.x[1][0..1] should not be filled with implicit initializers because the
344  // "base" initializer "xp" will provide values for them; l.lp.x[1] will be "baf".
345  //
346  // But if we have (Case#2):
347  // struct PP l = { .lp = xp, .lp.x[1] = { [2] = 'f' } };
348  //
349  // l.lp.x[1][0..1] are implicitly initialized and do not use values from the
350  // "base" initializer; l.lp.x[1] will be "\0\0f\0\0\0".
351  //
352  // To distinguish Case#1 from Case#2, and also to avoid leaving many "holes"
353  // in the InitListExpr, the "holes" in Case#1 are filled not with empty
354  // initializers but with special "NoInitExpr" place holders, which tells the
355  // CodeGen not to generate any initializers for these parts.
356  void FillInEmptyInitForBase(unsigned Init, const CXXBaseSpecifier &Base,
357  const InitializedEntity &ParentEntity,
358  InitListExpr *ILE, bool &RequiresSecondPass,
359  bool FillWithNoInit);
360  void FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
361  const InitializedEntity &ParentEntity,
362  InitListExpr *ILE, bool &RequiresSecondPass,
363  bool FillWithNoInit = false);
364  void FillInEmptyInitializations(const InitializedEntity &Entity,
365  InitListExpr *ILE, bool &RequiresSecondPass,
366  InitListExpr *OuterILE, unsigned OuterIndex,
367  bool FillWithNoInit = false);
368  bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
369  Expr *InitExpr, FieldDecl *Field,
370  bool TopLevelObject);
371  void CheckEmptyInitializable(const InitializedEntity &Entity,
372  SourceLocation Loc);
373 
374 public:
375  InitListChecker(Sema &S, const InitializedEntity &Entity,
376  InitListExpr *IL, QualType &T, bool VerifyOnly,
377  bool TreatUnavailableAsInvalid);
378  bool HadError() { return hadError; }
379 
380  // Retrieves the fully-structured initializer list used for
381  // semantic analysis and code generation.
382  InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
383 };
384 
385 } // end anonymous namespace
386 
387 ExprResult InitListChecker::PerformEmptyInit(Sema &SemaRef,
388  SourceLocation Loc,
389  const InitializedEntity &Entity,
390  bool VerifyOnly,
391  bool TreatUnavailableAsInvalid) {
393  true);
394  MultiExprArg SubInit;
395  Expr *InitExpr;
396  InitListExpr DummyInitList(SemaRef.Context, Loc, None, Loc);
397 
398  // C++ [dcl.init.aggr]p7:
399  // If there are fewer initializer-clauses in the list than there are
400  // members in the aggregate, then each member not explicitly initialized
401  // ...
402  bool EmptyInitList = SemaRef.getLangOpts().CPlusPlus11 &&
404  if (EmptyInitList) {
405  // C++1y / DR1070:
406  // shall be initialized [...] from an empty initializer list.
407  //
408  // We apply the resolution of this DR to C++11 but not C++98, since C++98
409  // does not have useful semantics for initialization from an init list.
410  // We treat this as copy-initialization, because aggregate initialization
411  // always performs copy-initialization on its elements.
412  //
413  // Only do this if we're initializing a class type, to avoid filling in
414  // the initializer list where possible.
415  InitExpr = VerifyOnly ? &DummyInitList : new (SemaRef.Context)
416  InitListExpr(SemaRef.Context, Loc, None, Loc);
417  InitExpr->setType(SemaRef.Context.VoidTy);
418  SubInit = InitExpr;
419  Kind = InitializationKind::CreateCopy(Loc, Loc);
420  } else {
421  // C++03:
422  // shall be value-initialized.
423  }
424 
425  InitializationSequence InitSeq(SemaRef, Entity, Kind, SubInit);
426  // libstdc++4.6 marks the vector default constructor as explicit in
427  // _GLIBCXX_DEBUG mode, so recover using the C++03 logic in that case.
428  // stlport does so too. Look for std::__debug for libstdc++, and for
429  // std:: for stlport. This is effectively a compiler-side implementation of
430  // LWG2193.
431  if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
435  InitSeq.getFailedCandidateSet()
436  .BestViableFunction(SemaRef, Kind.getLocation(), Best);
437  (void)O;
438  assert(O == OR_Success && "Inconsistent overload resolution");
439  CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
440  CXXRecordDecl *R = CtorDecl->getParent();
441 
442  if (CtorDecl->getMinRequiredArguments() == 0 &&
443  CtorDecl->isExplicit() && R->getDeclName() &&
444  SemaRef.SourceMgr.isInSystemHeader(CtorDecl->getLocation())) {
445  bool IsInStd = false;
446  for (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(R->getDeclContext());
447  ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
448  if (SemaRef.getStdNamespace()->InEnclosingNamespaceSetOf(ND))
449  IsInStd = true;
450  }
451 
452  if (IsInStd && llvm::StringSwitch<bool>(R->getName())
453  .Cases("basic_string", "deque", "forward_list", true)
454  .Cases("list", "map", "multimap", "multiset", true)
455  .Cases("priority_queue", "queue", "set", "stack", true)
456  .Cases("unordered_map", "unordered_set", "vector", true)
457  .Default(false)) {
458  InitSeq.InitializeFrom(
459  SemaRef, Entity,
460  InitializationKind::CreateValue(Loc, Loc, Loc, true),
461  MultiExprArg(), /*TopLevelOfInitList=*/false,
462  TreatUnavailableAsInvalid);
463  // Emit a warning for this. System header warnings aren't shown
464  // by default, but people working on system headers should see it.
465  if (!VerifyOnly) {
466  SemaRef.Diag(CtorDecl->getLocation(),
467  diag::warn_invalid_initializer_from_system_header);
468  if (Entity.getKind() == InitializedEntity::EK_Member)
469  SemaRef.Diag(Entity.getDecl()->getLocation(),
470  diag::note_used_in_initialization_here);
471  else if (Entity.getKind() == InitializedEntity::EK_ArrayElement)
472  SemaRef.Diag(Loc, diag::note_used_in_initialization_here);
473  }
474  }
475  }
476  }
477  if (!InitSeq) {
478  if (!VerifyOnly) {
479  InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
480  if (Entity.getKind() == InitializedEntity::EK_Member)
481  SemaRef.Diag(Entity.getDecl()->getLocation(),
482  diag::note_in_omitted_aggregate_initializer)
483  << /*field*/1 << Entity.getDecl();
484  else if (Entity.getKind() == InitializedEntity::EK_ArrayElement) {
485  bool IsTrailingArrayNewMember =
486  Entity.getParent() &&
488  SemaRef.Diag(Loc, diag::note_in_omitted_aggregate_initializer)
489  << (IsTrailingArrayNewMember ? 2 : /*array element*/0)
490  << Entity.getElementIndex();
491  }
492  }
493  return ExprError();
494  }
495 
496  return VerifyOnly ? ExprResult(static_cast<Expr *>(nullptr))
497  : InitSeq.Perform(SemaRef, Entity, Kind, SubInit);
498 }
499 
500 void InitListChecker::CheckEmptyInitializable(const InitializedEntity &Entity,
501  SourceLocation Loc) {
502  assert(VerifyOnly &&
503  "CheckEmptyInitializable is only inteded for verification mode.");
504  if (PerformEmptyInit(SemaRef, Loc, Entity, /*VerifyOnly*/true,
505  TreatUnavailableAsInvalid).isInvalid())
506  hadError = true;
507 }
508 
509 void InitListChecker::FillInEmptyInitForBase(
510  unsigned Init, const CXXBaseSpecifier &Base,
511  const InitializedEntity &ParentEntity, InitListExpr *ILE,
512  bool &RequiresSecondPass, bool FillWithNoInit) {
513  assert(Init < ILE->getNumInits() && "should have been expanded");
514 
516  SemaRef.Context, &Base, false, &ParentEntity);
517 
518  if (!ILE->getInit(Init)) {
519  ExprResult BaseInit =
520  FillWithNoInit ? new (SemaRef.Context) NoInitExpr(Base.getType())
521  : PerformEmptyInit(SemaRef, ILE->getLocEnd(), BaseEntity,
522  /*VerifyOnly*/ false,
523  TreatUnavailableAsInvalid);
524  if (BaseInit.isInvalid()) {
525  hadError = true;
526  return;
527  }
528 
529  ILE->setInit(Init, BaseInit.getAs<Expr>());
530  } else if (InitListExpr *InnerILE =
531  dyn_cast<InitListExpr>(ILE->getInit(Init))) {
532  FillInEmptyInitializations(BaseEntity, InnerILE, RequiresSecondPass,
533  ILE, Init, FillWithNoInit);
534  } else if (DesignatedInitUpdateExpr *InnerDIUE =
535  dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init))) {
536  FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),
537  RequiresSecondPass, ILE, Init,
538  /*FillWithNoInit =*/true);
539  }
540 }
541 
542 void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
543  const InitializedEntity &ParentEntity,
544  InitListExpr *ILE,
545  bool &RequiresSecondPass,
546  bool FillWithNoInit) {
547  SourceLocation Loc = ILE->getLocEnd();
548  unsigned NumInits = ILE->getNumInits();
549  InitializedEntity MemberEntity
550  = InitializedEntity::InitializeMember(Field, &ParentEntity);
551 
552  if (const RecordType *RType = ILE->getType()->getAs<RecordType>())
553  if (!RType->getDecl()->isUnion())
554  assert(Init < NumInits && "This ILE should have been expanded");
555 
556  if (Init >= NumInits || !ILE->getInit(Init)) {
557  if (FillWithNoInit) {
558  Expr *Filler = new (SemaRef.Context) NoInitExpr(Field->getType());
559  if (Init < NumInits)
560  ILE->setInit(Init, Filler);
561  else
562  ILE->updateInit(SemaRef.Context, Init, Filler);
563  return;
564  }
565  // C++1y [dcl.init.aggr]p7:
566  // If there are fewer initializer-clauses in the list than there are
567  // members in the aggregate, then each member not explicitly initialized
568  // shall be initialized from its brace-or-equal-initializer [...]
569  if (Field->hasInClassInitializer()) {
570  ExprResult DIE = SemaRef.BuildCXXDefaultInitExpr(Loc, Field);
571  if (DIE.isInvalid()) {
572  hadError = true;
573  return;
574  }
575  if (Init < NumInits)
576  ILE->setInit(Init, DIE.get());
577  else {
578  ILE->updateInit(SemaRef.Context, Init, DIE.get());
579  RequiresSecondPass = true;
580  }
581  return;
582  }
583 
584  if (Field->getType()->isReferenceType()) {
585  // C++ [dcl.init.aggr]p9:
586  // If an incomplete or empty initializer-list leaves a
587  // member of reference type uninitialized, the program is
588  // ill-formed.
589  SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
590  << Field->getType()
591  << ILE->getSyntacticForm()->getSourceRange();
592  SemaRef.Diag(Field->getLocation(),
593  diag::note_uninit_reference_member);
594  hadError = true;
595  return;
596  }
597 
598  ExprResult MemberInit = PerformEmptyInit(SemaRef, Loc, MemberEntity,
599  /*VerifyOnly*/false,
600  TreatUnavailableAsInvalid);
601  if (MemberInit.isInvalid()) {
602  hadError = true;
603  return;
604  }
605 
606  if (hadError) {
607  // Do nothing
608  } else if (Init < NumInits) {
609  ILE->setInit(Init, MemberInit.getAs<Expr>());
610  } else if (!isa<ImplicitValueInitExpr>(MemberInit.get())) {
611  // Empty initialization requires a constructor call, so
612  // extend the initializer list to include the constructor
613  // call and make a note that we'll need to take another pass
614  // through the initializer list.
615  ILE->updateInit(SemaRef.Context, Init, MemberInit.getAs<Expr>());
616  RequiresSecondPass = true;
617  }
618  } else if (InitListExpr *InnerILE
619  = dyn_cast<InitListExpr>(ILE->getInit(Init)))
620  FillInEmptyInitializations(MemberEntity, InnerILE,
621  RequiresSecondPass, ILE, Init, FillWithNoInit);
622  else if (DesignatedInitUpdateExpr *InnerDIUE
623  = dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init)))
624  FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
625  RequiresSecondPass, ILE, Init,
626  /*FillWithNoInit =*/true);
627 }
628 
629 /// Recursively replaces NULL values within the given initializer list
630 /// with expressions that perform value-initialization of the
631 /// appropriate type, and finish off the InitListExpr formation.
632 void
633 InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity,
634  InitListExpr *ILE,
635  bool &RequiresSecondPass,
636  InitListExpr *OuterILE,
637  unsigned OuterIndex,
638  bool FillWithNoInit) {
639  assert((ILE->getType() != SemaRef.Context.VoidTy) &&
640  "Should not have void type");
641 
642  // If this is a nested initializer list, we might have changed its contents
643  // (and therefore some of its properties, such as instantiation-dependence)
644  // while filling it in. Inform the outer initializer list so that its state
645  // can be updated to match.
646  // FIXME: We should fully build the inner initializers before constructing
647  // the outer InitListExpr instead of mutating AST nodes after they have
648  // been used as subexpressions of other nodes.
649  struct UpdateOuterILEWithUpdatedInit {
650  InitListExpr *Outer;
651  unsigned OuterIndex;
652  ~UpdateOuterILEWithUpdatedInit() {
653  if (Outer)
654  Outer->setInit(OuterIndex, Outer->getInit(OuterIndex));
655  }
656  } UpdateOuterRAII = {OuterILE, OuterIndex};
657 
658  // A transparent ILE is not performing aggregate initialization and should
659  // not be filled in.
660  if (ILE->isTransparent())
661  return;
662 
663  if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
664  const RecordDecl *RDecl = RType->getDecl();
665  if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())
666  FillInEmptyInitForField(0, ILE->getInitializedFieldInUnion(),
667  Entity, ILE, RequiresSecondPass, FillWithNoInit);
668  else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
669  cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
670  for (auto *Field : RDecl->fields()) {
671  if (Field->hasInClassInitializer()) {
672  FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass,
673  FillWithNoInit);
674  break;
675  }
676  }
677  } else {
678  // The fields beyond ILE->getNumInits() are default initialized, so in
679  // order to leave them uninitialized, the ILE is expanded and the extra
680  // fields are then filled with NoInitExpr.
681  unsigned NumElems = numStructUnionElements(ILE->getType());
682  if (RDecl->hasFlexibleArrayMember())
683  ++NumElems;
684  if (ILE->getNumInits() < NumElems)
685  ILE->resizeInits(SemaRef.Context, NumElems);
686 
687  unsigned Init = 0;
688 
689  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {
690  for (auto &Base : CXXRD->bases()) {
691  if (hadError)
692  return;
693 
694  FillInEmptyInitForBase(Init, Base, Entity, ILE, RequiresSecondPass,
695  FillWithNoInit);
696  ++Init;
697  }
698  }
699 
700  for (auto *Field : RDecl->fields()) {
701  if (Field->isUnnamedBitfield())
702  continue;
703 
704  if (hadError)
705  return;
706 
707  FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass,
708  FillWithNoInit);
709  if (hadError)
710  return;
711 
712  ++Init;
713 
714  // Only look at the first initialization of a union.
715  if (RDecl->isUnion())
716  break;
717  }
718  }
719 
720  return;
721  }
722 
723  QualType ElementType;
724 
725  InitializedEntity ElementEntity = Entity;
726  unsigned NumInits = ILE->getNumInits();
727  unsigned NumElements = NumInits;
728  if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
729  ElementType = AType->getElementType();
730  if (const auto *CAType = dyn_cast<ConstantArrayType>(AType))
731  NumElements = CAType->getSize().getZExtValue();
732  // For an array new with an unknown bound, ask for one additional element
733  // in order to populate the array filler.
734  if (Entity.isVariableLengthArrayNew())
735  ++NumElements;
736  ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
737  0, Entity);
738  } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
739  ElementType = VType->getElementType();
740  NumElements = VType->getNumElements();
741  ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
742  0, Entity);
743  } else
744  ElementType = ILE->getType();
745 
746  for (unsigned Init = 0; Init != NumElements; ++Init) {
747  if (hadError)
748  return;
749 
750  if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
751  ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
752  ElementEntity.setElementIndex(Init);
753 
754  if (Init >= NumInits && ILE->hasArrayFiller())
755  return;
756 
757  Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr);
758  if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
759  ILE->setInit(Init, ILE->getArrayFiller());
760  else if (!InitExpr && !ILE->hasArrayFiller()) {
761  Expr *Filler = nullptr;
762 
763  if (FillWithNoInit)
764  Filler = new (SemaRef.Context) NoInitExpr(ElementType);
765  else {
766  ExprResult ElementInit = PerformEmptyInit(SemaRef, ILE->getLocEnd(),
767  ElementEntity,
768  /*VerifyOnly*/false,
769  TreatUnavailableAsInvalid);
770  if (ElementInit.isInvalid()) {
771  hadError = true;
772  return;
773  }
774 
775  Filler = ElementInit.getAs<Expr>();
776  }
777 
778  if (hadError) {
779  // Do nothing
780  } else if (Init < NumInits) {
781  // For arrays, just set the expression used for value-initialization
782  // of the "holes" in the array.
783  if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
784  ILE->setArrayFiller(Filler);
785  else
786  ILE->setInit(Init, Filler);
787  } else {
788  // For arrays, just set the expression used for value-initialization
789  // of the rest of elements and exit.
790  if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
791  ILE->setArrayFiller(Filler);
792  return;
793  }
794 
795  if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {
796  // Empty initialization requires a constructor call, so
797  // extend the initializer list to include the constructor
798  // call and make a note that we'll need to take another pass
799  // through the initializer list.
800  ILE->updateInit(SemaRef.Context, Init, Filler);
801  RequiresSecondPass = true;
802  }
803  }
804  } else if (InitListExpr *InnerILE
805  = dyn_cast_or_null<InitListExpr>(InitExpr))
806  FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
807  ILE, Init, FillWithNoInit);
808  else if (DesignatedInitUpdateExpr *InnerDIUE
809  = dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr))
810  FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
811  RequiresSecondPass, ILE, Init,
812  /*FillWithNoInit =*/true);
813  }
814 }
815 
816 InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
817  InitListExpr *IL, QualType &T,
818  bool VerifyOnly,
819  bool TreatUnavailableAsInvalid)
820  : SemaRef(S), VerifyOnly(VerifyOnly),
821  TreatUnavailableAsInvalid(TreatUnavailableAsInvalid) {
822  // FIXME: Check that IL isn't already the semantic form of some other
823  // InitListExpr. If it is, we'd create a broken AST.
824 
825  hadError = false;
826 
827  FullyStructuredList =
828  getStructuredSubobjectInit(IL, 0, T, nullptr, 0, IL->getSourceRange());
829  CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
830  /*TopLevelObject=*/true);
831 
832  if (!hadError && !VerifyOnly) {
833  bool RequiresSecondPass = false;
834  FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass,
835  /*OuterILE=*/nullptr, /*OuterIndex=*/0);
836  if (RequiresSecondPass && !hadError)
837  FillInEmptyInitializations(Entity, FullyStructuredList,
838  RequiresSecondPass, nullptr, 0);
839  }
840 }
841 
842 int InitListChecker::numArrayElements(QualType DeclType) {
843  // FIXME: use a proper constant
844  int maxElements = 0x7FFFFFFF;
845  if (const ConstantArrayType *CAT =
846  SemaRef.Context.getAsConstantArrayType(DeclType)) {
847  maxElements = static_cast<int>(CAT->getSize().getZExtValue());
848  }
849  return maxElements;
850 }
851 
852 int InitListChecker::numStructUnionElements(QualType DeclType) {
853  RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
854  int InitializableMembers = 0;
855  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl))
856  InitializableMembers += CXXRD->getNumBases();
857  for (const auto *Field : structDecl->fields())
858  if (!Field->isUnnamedBitfield())
859  ++InitializableMembers;
860 
861  if (structDecl->isUnion())
862  return std::min(InitializableMembers, 1);
863  return InitializableMembers - structDecl->hasFlexibleArrayMember();
864 }
865 
866 /// Determine whether Entity is an entity for which it is idiomatic to elide
867 /// the braces in aggregate initialization.
869  // Recursive initialization of the one and only field within an aggregate
870  // class is considered idiomatic. This case arises in particular for
871  // initialization of std::array, where the C++ standard suggests the idiom of
872  //
873  // std::array<T, N> arr = {1, 2, 3};
874  //
875  // (where std::array is an aggregate struct containing a single array field.
876 
877  // FIXME: Should aggregate initialization of a struct with a single
878  // base class and no members also suppress the warning?
879  if (Entity.getKind() != InitializedEntity::EK_Member || !Entity.getParent())
880  return false;
881 
882  auto *ParentRD =
883  Entity.getParent()->getType()->castAs<RecordType>()->getDecl();
884  if (CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(ParentRD))
885  if (CXXRD->getNumBases())
886  return false;
887 
888  auto FieldIt = ParentRD->field_begin();
889  assert(FieldIt != ParentRD->field_end() &&
890  "no fields but have initializer for member?");
891  return ++FieldIt == ParentRD->field_end();
892 }
893 
894 /// Check whether the range of the initializer \p ParentIList from element
895 /// \p Index onwards can be used to initialize an object of type \p T. Update
896 /// \p Index to indicate how many elements of the list were consumed.
897 ///
898 /// This also fills in \p StructuredList, from element \p StructuredIndex
899 /// onwards, with the fully-braced, desugared form of the initialization.
900 void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
901  InitListExpr *ParentIList,
902  QualType T, unsigned &Index,
903  InitListExpr *StructuredList,
904  unsigned &StructuredIndex) {
905  int maxElements = 0;
906 
907  if (T->isArrayType())
908  maxElements = numArrayElements(T);
909  else if (T->isRecordType())
910  maxElements = numStructUnionElements(T);
911  else if (T->isVectorType())
912  maxElements = T->getAs<VectorType>()->getNumElements();
913  else
914  llvm_unreachable("CheckImplicitInitList(): Illegal type");
915 
916  if (maxElements == 0) {
917  if (!VerifyOnly)
918  SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
919  diag::err_implicit_empty_initializer);
920  ++Index;
921  hadError = true;
922  return;
923  }
924 
925  // Build a structured initializer list corresponding to this subobject.
926  InitListExpr *StructuredSubobjectInitList
927  = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
928  StructuredIndex,
929  SourceRange(ParentIList->getInit(Index)->getLocStart(),
930  ParentIList->getSourceRange().getEnd()));
931  unsigned StructuredSubobjectInitIndex = 0;
932 
933  // Check the element types and build the structural subobject.
934  unsigned StartIndex = Index;
935  CheckListElementTypes(Entity, ParentIList, T,
936  /*SubobjectIsDesignatorContext=*/false, Index,
937  StructuredSubobjectInitList,
938  StructuredSubobjectInitIndex);
939 
940  if (!VerifyOnly) {
941  StructuredSubobjectInitList->setType(T);
942 
943  unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
944  // Update the structured sub-object initializer so that it's ending
945  // range corresponds with the end of the last initializer it used.
946  if (EndIndex < ParentIList->getNumInits() &&
947  ParentIList->getInit(EndIndex)) {
948  SourceLocation EndLoc
949  = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
950  StructuredSubobjectInitList->setRBraceLoc(EndLoc);
951  }
952 
953  // Complain about missing braces.
954  if ((T->isArrayType() || T->isRecordType()) &&
955  !ParentIList->isIdiomaticZeroInitializer(SemaRef.getLangOpts()) &&
957  SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
958  diag::warn_missing_braces)
959  << StructuredSubobjectInitList->getSourceRange()
961  StructuredSubobjectInitList->getLocStart(), "{")
963  SemaRef.getLocForEndOfToken(
964  StructuredSubobjectInitList->getLocEnd()),
965  "}");
966  }
967  }
968 }
969 
970 /// Warn that \p Entity was of scalar type and was initialized by a
971 /// single-element braced initializer list.
972 static void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity,
973  SourceRange Braces) {
974  // Don't warn during template instantiation. If the initialization was
975  // non-dependent, we warned during the initial parse; otherwise, the
976  // type might not be scalar in some uses of the template.
977  if (S.inTemplateInstantiation())
978  return;
979 
980  unsigned DiagID = 0;
981 
982  switch (Entity.getKind()) {
989  // Extra braces here are suspicious.
990  DiagID = diag::warn_braces_around_scalar_init;
991  break;
992 
994  // Warn on aggregate initialization but not on ctor init list or
995  // default member initializer.
996  if (Entity.getParent())
997  DiagID = diag::warn_braces_around_scalar_init;
998  break;
999 
1002  // No warning, might be direct-list-initialization.
1003  // FIXME: Should we warn for copy-list-initialization in these cases?
1004  break;
1005 
1009  // No warning, braces are part of the syntax of the underlying construct.
1010  break;
1011 
1013  // No warning, we already warned when initializing the result.
1014  break;
1015 
1022  llvm_unreachable("unexpected braced scalar init");
1023  }
1024 
1025  if (DiagID) {
1026  S.Diag(Braces.getBegin(), DiagID)
1027  << Braces
1028  << FixItHint::CreateRemoval(Braces.getBegin())
1029  << FixItHint::CreateRemoval(Braces.getEnd());
1030  }
1031 }
1032 
1033 /// Check whether the initializer \p IList (that was written with explicit
1034 /// braces) can be used to initialize an object of type \p T.
1035 ///
1036 /// This also fills in \p StructuredList with the fully-braced, desugared
1037 /// form of the initialization.
1038 void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
1039  InitListExpr *IList, QualType &T,
1040  InitListExpr *StructuredList,
1041  bool TopLevelObject) {
1042  if (!VerifyOnly) {
1043  SyntacticToSemantic[IList] = StructuredList;
1044  StructuredList->setSyntacticForm(IList);
1045  }
1046 
1047  unsigned Index = 0, StructuredIndex = 0;
1048  CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
1049  Index, StructuredList, StructuredIndex, TopLevelObject);
1050  if (!VerifyOnly) {
1051  QualType ExprTy = T;
1052  if (!ExprTy->isArrayType())
1053  ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context);
1054  IList->setType(ExprTy);
1055  StructuredList->setType(ExprTy);
1056  }
1057  if (hadError)
1058  return;
1059 
1060  if (Index < IList->getNumInits()) {
1061  // We have leftover initializers
1062  if (VerifyOnly) {
1063  if (SemaRef.getLangOpts().CPlusPlus ||
1064  (SemaRef.getLangOpts().OpenCL &&
1065  IList->getType()->isVectorType())) {
1066  hadError = true;
1067  }
1068  return;
1069  }
1070 
1071  if (StructuredIndex == 1 &&
1072  IsStringInit(StructuredList->getInit(0), T, SemaRef.Context) ==
1073  SIF_None) {
1074  unsigned DK = diag::ext_excess_initializers_in_char_array_initializer;
1075  if (SemaRef.getLangOpts().CPlusPlus) {
1076  DK = diag::err_excess_initializers_in_char_array_initializer;
1077  hadError = true;
1078  }
1079  // Special-case
1080  SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
1081  << IList->getInit(Index)->getSourceRange();
1082  } else if (!T->isIncompleteType()) {
1083  // Don't complain for incomplete types, since we'll get an error
1084  // elsewhere
1085  QualType CurrentObjectType = StructuredList->getType();
1086  int initKind =
1087  CurrentObjectType->isArrayType()? 0 :
1088  CurrentObjectType->isVectorType()? 1 :
1089  CurrentObjectType->isScalarType()? 2 :
1090  CurrentObjectType->isUnionType()? 3 :
1091  4;
1092 
1093  unsigned DK = diag::ext_excess_initializers;
1094  if (SemaRef.getLangOpts().CPlusPlus) {
1095  DK = diag::err_excess_initializers;
1096  hadError = true;
1097  }
1098  if (SemaRef.getLangOpts().OpenCL && initKind == 1) {
1099  DK = diag::err_excess_initializers;
1100  hadError = true;
1101  }
1102 
1103  SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
1104  << initKind << IList->getInit(Index)->getSourceRange();
1105  }
1106  }
1107 
1108  if (!VerifyOnly && T->isScalarType() &&
1109  IList->getNumInits() == 1 && !isa<InitListExpr>(IList->getInit(0)))
1110  warnBracedScalarInit(SemaRef, Entity, IList->getSourceRange());
1111 }
1112 
1113 void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
1114  InitListExpr *IList,
1115  QualType &DeclType,
1116  bool SubobjectIsDesignatorContext,
1117  unsigned &Index,
1118  InitListExpr *StructuredList,
1119  unsigned &StructuredIndex,
1120  bool TopLevelObject) {
1121  if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
1122  // Explicitly braced initializer for complex type can be real+imaginary
1123  // parts.
1124  CheckComplexType(Entity, IList, DeclType, Index,
1125  StructuredList, StructuredIndex);
1126  } else if (DeclType->isScalarType()) {
1127  CheckScalarType(Entity, IList, DeclType, Index,
1128  StructuredList, StructuredIndex);
1129  } else if (DeclType->isVectorType()) {
1130  CheckVectorType(Entity, IList, DeclType, Index,
1131  StructuredList, StructuredIndex);
1132  } else if (DeclType->isRecordType()) {
1133  assert(DeclType->isAggregateType() &&
1134  "non-aggregate records should be handed in CheckSubElementType");
1135  RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1136  auto Bases =
1139  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1140  Bases = CXXRD->bases();
1141  CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(),
1142  SubobjectIsDesignatorContext, Index, StructuredList,
1143  StructuredIndex, TopLevelObject);
1144  } else if (DeclType->isArrayType()) {
1145  llvm::APSInt Zero(
1146  SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
1147  false);
1148  CheckArrayType(Entity, IList, DeclType, Zero,
1149  SubobjectIsDesignatorContext, Index,
1150  StructuredList, StructuredIndex);
1151  } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
1152  // This type is invalid, issue a diagnostic.
1153  ++Index;
1154  if (!VerifyOnly)
1155  SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
1156  << DeclType;
1157  hadError = true;
1158  } else if (DeclType->isReferenceType()) {
1159  CheckReferenceType(Entity, IList, DeclType, Index,
1160  StructuredList, StructuredIndex);
1161  } else if (DeclType->isObjCObjectType()) {
1162  if (!VerifyOnly)
1163  SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
1164  << DeclType;
1165  hadError = true;
1166  } else {
1167  if (!VerifyOnly)
1168  SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
1169  << DeclType;
1170  hadError = true;
1171  }
1172 }
1173 
1174 void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
1175  InitListExpr *IList,
1176  QualType ElemType,
1177  unsigned &Index,
1178  InitListExpr *StructuredList,
1179  unsigned &StructuredIndex) {
1180  Expr *expr = IList->getInit(Index);
1181 
1182  if (ElemType->isReferenceType())
1183  return CheckReferenceType(Entity, IList, ElemType, Index,
1184  StructuredList, StructuredIndex);
1185 
1186  if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
1187  if (SubInitList->getNumInits() == 1 &&
1188  IsStringInit(SubInitList->getInit(0), ElemType, SemaRef.Context) ==
1189  SIF_None) {
1190  expr = SubInitList->getInit(0);
1191  } else if (!SemaRef.getLangOpts().CPlusPlus) {
1192  InitListExpr *InnerStructuredList
1193  = getStructuredSubobjectInit(IList, Index, ElemType,
1194  StructuredList, StructuredIndex,
1195  SubInitList->getSourceRange(), true);
1196  CheckExplicitInitList(Entity, SubInitList, ElemType,
1197  InnerStructuredList);
1198 
1199  if (!hadError && !VerifyOnly) {
1200  bool RequiresSecondPass = false;
1201  FillInEmptyInitializations(Entity, InnerStructuredList,
1202  RequiresSecondPass, StructuredList,
1203  StructuredIndex);
1204  if (RequiresSecondPass && !hadError)
1205  FillInEmptyInitializations(Entity, InnerStructuredList,
1206  RequiresSecondPass, StructuredList,
1207  StructuredIndex);
1208  }
1209  ++StructuredIndex;
1210  ++Index;
1211  return;
1212  }
1213  // C++ initialization is handled later.
1214  } else if (isa<ImplicitValueInitExpr>(expr)) {
1215  // This happens during template instantiation when we see an InitListExpr
1216  // that we've already checked once.
1217  assert(SemaRef.Context.hasSameType(expr->getType(), ElemType) &&
1218  "found implicit initialization for the wrong type");
1219  if (!VerifyOnly)
1220  UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1221  ++Index;
1222  return;
1223  }
1224 
1225  if (SemaRef.getLangOpts().CPlusPlus) {
1226  // C++ [dcl.init.aggr]p2:
1227  // Each member is copy-initialized from the corresponding
1228  // initializer-clause.
1229 
1230  // FIXME: Better EqualLoc?
1233  InitializationSequence Seq(SemaRef, Entity, Kind, expr,
1234  /*TopLevelOfInitList*/ true);
1235 
1236  // C++14 [dcl.init.aggr]p13:
1237  // If the assignment-expression can initialize a member, the member is
1238  // initialized. Otherwise [...] brace elision is assumed
1239  //
1240  // Brace elision is never performed if the element is not an
1241  // assignment-expression.
1242  if (Seq || isa<InitListExpr>(expr)) {
1243  if (!VerifyOnly) {
1244  ExprResult Result =
1245  Seq.Perform(SemaRef, Entity, Kind, expr);
1246  if (Result.isInvalid())
1247  hadError = true;
1248 
1249  UpdateStructuredListElement(StructuredList, StructuredIndex,
1250  Result.getAs<Expr>());
1251  } else if (!Seq)
1252  hadError = true;
1253  ++Index;
1254  return;
1255  }
1256 
1257  // Fall through for subaggregate initialization
1258  } else if (ElemType->isScalarType() || ElemType->isAtomicType()) {
1259  // FIXME: Need to handle atomic aggregate types with implicit init lists.
1260  return CheckScalarType(Entity, IList, ElemType, Index,
1261  StructuredList, StructuredIndex);
1262  } else if (const ArrayType *arrayType =
1263  SemaRef.Context.getAsArrayType(ElemType)) {
1264  // arrayType can be incomplete if we're initializing a flexible
1265  // array member. There's nothing we can do with the completed
1266  // type here, though.
1267 
1268  if (IsStringInit(expr, arrayType, SemaRef.Context) == SIF_None) {
1269  if (!VerifyOnly) {
1270  CheckStringInit(expr, ElemType, arrayType, SemaRef);
1271  UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1272  }
1273  ++Index;
1274  return;
1275  }
1276 
1277  // Fall through for subaggregate initialization.
1278 
1279  } else {
1280  assert((ElemType->isRecordType() || ElemType->isVectorType() ||
1281  ElemType->isOpenCLSpecificType()) && "Unexpected type");
1282 
1283  // C99 6.7.8p13:
1284  //
1285  // The initializer for a structure or union object that has
1286  // automatic storage duration shall be either an initializer
1287  // list as described below, or a single expression that has
1288  // compatible structure or union type. In the latter case, the
1289  // initial value of the object, including unnamed members, is
1290  // that of the expression.
1291  ExprResult ExprRes = expr;
1293  ElemType, ExprRes, !VerifyOnly) != Sema::Incompatible) {
1294  if (ExprRes.isInvalid())
1295  hadError = true;
1296  else {
1297  ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.get());
1298  if (ExprRes.isInvalid())
1299  hadError = true;
1300  }
1301  UpdateStructuredListElement(StructuredList, StructuredIndex,
1302  ExprRes.getAs<Expr>());
1303  ++Index;
1304  return;
1305  }
1306  ExprRes.get();
1307  // Fall through for subaggregate initialization
1308  }
1309 
1310  // C++ [dcl.init.aggr]p12:
1311  //
1312  // [...] Otherwise, if the member is itself a non-empty
1313  // subaggregate, brace elision is assumed and the initializer is
1314  // considered for the initialization of the first member of
1315  // the subaggregate.
1316  // OpenCL vector initializer is handled elsewhere.
1317  if ((!SemaRef.getLangOpts().OpenCL && ElemType->isVectorType()) ||
1318  ElemType->isAggregateType()) {
1319  CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
1320  StructuredIndex);
1321  ++StructuredIndex;
1322  } else {
1323  if (!VerifyOnly) {
1324  // We cannot initialize this element, so let
1325  // PerformCopyInitialization produce the appropriate diagnostic.
1326  SemaRef.PerformCopyInitialization(Entity, SourceLocation(), expr,
1327  /*TopLevelOfInitList=*/true);
1328  }
1329  hadError = true;
1330  ++Index;
1331  ++StructuredIndex;
1332  }
1333 }
1334 
1335 void InitListChecker::CheckComplexType(const InitializedEntity &Entity,
1336  InitListExpr *IList, QualType DeclType,
1337  unsigned &Index,
1338  InitListExpr *StructuredList,
1339  unsigned &StructuredIndex) {
1340  assert(Index == 0 && "Index in explicit init list must be zero");
1341 
1342  // As an extension, clang supports complex initializers, which initialize
1343  // a complex number component-wise. When an explicit initializer list for
1344  // a complex number contains two two initializers, this extension kicks in:
1345  // it exepcts the initializer list to contain two elements convertible to
1346  // the element type of the complex type. The first element initializes
1347  // the real part, and the second element intitializes the imaginary part.
1348 
1349  if (IList->getNumInits() != 2)
1350  return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1351  StructuredIndex);
1352 
1353  // This is an extension in C. (The builtin _Complex type does not exist
1354  // in the C++ standard.)
1355  if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly)
1356  SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init)
1357  << IList->getSourceRange();
1358 
1359  // Initialize the complex number.
1360  QualType elementType = DeclType->getAs<ComplexType>()->getElementType();
1361  InitializedEntity ElementEntity =
1362  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1363 
1364  for (unsigned i = 0; i < 2; ++i) {
1365  ElementEntity.setElementIndex(Index);
1366  CheckSubElementType(ElementEntity, IList, elementType, Index,
1367  StructuredList, StructuredIndex);
1368  }
1369 }
1370 
1371 void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
1372  InitListExpr *IList, QualType DeclType,
1373  unsigned &Index,
1374  InitListExpr *StructuredList,
1375  unsigned &StructuredIndex) {
1376  if (Index >= IList->getNumInits()) {
1377  if (!VerifyOnly)
1378  SemaRef.Diag(IList->getLocStart(),
1379  SemaRef.getLangOpts().CPlusPlus11 ?
1380  diag::warn_cxx98_compat_empty_scalar_initializer :
1381  diag::err_empty_scalar_initializer)
1382  << IList->getSourceRange();
1383  hadError = !SemaRef.getLangOpts().CPlusPlus11;
1384  ++Index;
1385  ++StructuredIndex;
1386  return;
1387  }
1388 
1389  Expr *expr = IList->getInit(Index);
1390  if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
1391  // FIXME: This is invalid, and accepting it causes overload resolution
1392  // to pick the wrong overload in some corner cases.
1393  if (!VerifyOnly)
1394  SemaRef.Diag(SubIList->getLocStart(),
1395  diag::ext_many_braces_around_scalar_init)
1396  << SubIList->getSourceRange();
1397 
1398  CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1399  StructuredIndex);
1400  return;
1401  } else if (isa<DesignatedInitExpr>(expr)) {
1402  if (!VerifyOnly)
1403  SemaRef.Diag(expr->getLocStart(),
1404  diag::err_designator_for_scalar_init)
1405  << DeclType << expr->getSourceRange();
1406  hadError = true;
1407  ++Index;
1408  ++StructuredIndex;
1409  return;
1410  }
1411 
1412  if (VerifyOnly) {
1413  if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1414  hadError = true;
1415  ++Index;
1416  return;
1417  }
1418 
1419  ExprResult Result =
1420  SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1421  /*TopLevelOfInitList=*/true);
1422 
1423  Expr *ResultExpr = nullptr;
1424 
1425  if (Result.isInvalid())
1426  hadError = true; // types weren't compatible.
1427  else {
1428  ResultExpr = Result.getAs<Expr>();
1429 
1430  if (ResultExpr != expr) {
1431  // The type was promoted, update initializer list.
1432  IList->setInit(Index, ResultExpr);
1433  }
1434  }
1435  if (hadError)
1436  ++StructuredIndex;
1437  else
1438  UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1439  ++Index;
1440 }
1441 
1442 void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
1443  InitListExpr *IList, QualType DeclType,
1444  unsigned &Index,
1445  InitListExpr *StructuredList,
1446  unsigned &StructuredIndex) {
1447  if (Index >= IList->getNumInits()) {
1448  // FIXME: It would be wonderful if we could point at the actual member. In
1449  // general, it would be useful to pass location information down the stack,
1450  // so that we know the location (or decl) of the "current object" being
1451  // initialized.
1452  if (!VerifyOnly)
1453  SemaRef.Diag(IList->getLocStart(),
1454  diag::err_init_reference_member_uninitialized)
1455  << DeclType
1456  << IList->getSourceRange();
1457  hadError = true;
1458  ++Index;
1459  ++StructuredIndex;
1460  return;
1461  }
1462 
1463  Expr *expr = IList->getInit(Index);
1464  if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) {
1465  if (!VerifyOnly)
1466  SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
1467  << DeclType << IList->getSourceRange();
1468  hadError = true;
1469  ++Index;
1470  ++StructuredIndex;
1471  return;
1472  }
1473 
1474  if (VerifyOnly) {
1475  if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1476  hadError = true;
1477  ++Index;
1478  return;
1479  }
1480 
1481  ExprResult Result =
1482  SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1483  /*TopLevelOfInitList=*/true);
1484 
1485  if (Result.isInvalid())
1486  hadError = true;
1487 
1488  expr = Result.getAs<Expr>();
1489  IList->setInit(Index, expr);
1490 
1491  if (hadError)
1492  ++StructuredIndex;
1493  else
1494  UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1495  ++Index;
1496 }
1497 
1498 void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
1499  InitListExpr *IList, QualType DeclType,
1500  unsigned &Index,
1501  InitListExpr *StructuredList,
1502  unsigned &StructuredIndex) {
1503  const VectorType *VT = DeclType->getAs<VectorType>();
1504  unsigned maxElements = VT->getNumElements();
1505  unsigned numEltsInit = 0;
1506  QualType elementType = VT->getElementType();
1507 
1508  if (Index >= IList->getNumInits()) {
1509  // Make sure the element type can be value-initialized.
1510  if (VerifyOnly)
1511  CheckEmptyInitializable(
1512  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity),
1513  IList->getLocEnd());
1514  return;
1515  }
1516 
1517  if (!SemaRef.getLangOpts().OpenCL) {
1518  // If the initializing element is a vector, try to copy-initialize
1519  // instead of breaking it apart (which is doomed to failure anyway).
1520  Expr *Init = IList->getInit(Index);
1521  if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
1522  if (VerifyOnly) {
1523  if (!SemaRef.CanPerformCopyInitialization(Entity, Init))
1524  hadError = true;
1525  ++Index;
1526  return;
1527  }
1528 
1529  ExprResult Result =
1530  SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(), Init,
1531  /*TopLevelOfInitList=*/true);
1532 
1533  Expr *ResultExpr = nullptr;
1534  if (Result.isInvalid())
1535  hadError = true; // types weren't compatible.
1536  else {
1537  ResultExpr = Result.getAs<Expr>();
1538 
1539  if (ResultExpr != Init) {
1540  // The type was promoted, update initializer list.
1541  IList->setInit(Index, ResultExpr);
1542  }
1543  }
1544  if (hadError)
1545  ++StructuredIndex;
1546  else
1547  UpdateStructuredListElement(StructuredList, StructuredIndex,
1548  ResultExpr);
1549  ++Index;
1550  return;
1551  }
1552 
1553  InitializedEntity ElementEntity =
1554  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1555 
1556  for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1557  // Don't attempt to go past the end of the init list
1558  if (Index >= IList->getNumInits()) {
1559  if (VerifyOnly)
1560  CheckEmptyInitializable(ElementEntity, IList->getLocEnd());
1561  break;
1562  }
1563 
1564  ElementEntity.setElementIndex(Index);
1565  CheckSubElementType(ElementEntity, IList, elementType, Index,
1566  StructuredList, StructuredIndex);
1567  }
1568 
1569  if (VerifyOnly)
1570  return;
1571 
1572  bool isBigEndian = SemaRef.Context.getTargetInfo().isBigEndian();
1573  const VectorType *T = Entity.getType()->getAs<VectorType>();
1574  if (isBigEndian && (T->getVectorKind() == VectorType::NeonVector ||
1576  // The ability to use vector initializer lists is a GNU vector extension
1577  // and is unrelated to the NEON intrinsics in arm_neon.h. On little
1578  // endian machines it works fine, however on big endian machines it
1579  // exhibits surprising behaviour:
1580  //
1581  // uint32x2_t x = {42, 64};
1582  // return vget_lane_u32(x, 0); // Will return 64.
1583  //
1584  // Because of this, explicitly call out that it is non-portable.
1585  //
1586  SemaRef.Diag(IList->getLocStart(),
1587  diag::warn_neon_vector_initializer_non_portable);
1588 
1589  const char *typeCode;
1590  unsigned typeSize = SemaRef.Context.getTypeSize(elementType);
1591 
1592  if (elementType->isFloatingType())
1593  typeCode = "f";
1594  else if (elementType->isSignedIntegerType())
1595  typeCode = "s";
1596  else if (elementType->isUnsignedIntegerType())
1597  typeCode = "u";
1598  else
1599  llvm_unreachable("Invalid element type!");
1600 
1601  SemaRef.Diag(IList->getLocStart(),
1602  SemaRef.Context.getTypeSize(VT) > 64 ?
1603  diag::note_neon_vector_initializer_non_portable_q :
1604  diag::note_neon_vector_initializer_non_portable)
1605  << typeCode << typeSize;
1606  }
1607 
1608  return;
1609  }
1610 
1611  InitializedEntity ElementEntity =
1612  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1613 
1614  // OpenCL initializers allows vectors to be constructed from vectors.
1615  for (unsigned i = 0; i < maxElements; ++i) {
1616  // Don't attempt to go past the end of the init list
1617  if (Index >= IList->getNumInits())
1618  break;
1619 
1620  ElementEntity.setElementIndex(Index);
1621 
1622  QualType IType = IList->getInit(Index)->getType();
1623  if (!IType->isVectorType()) {
1624  CheckSubElementType(ElementEntity, IList, elementType, Index,
1625  StructuredList, StructuredIndex);
1626  ++numEltsInit;
1627  } else {
1628  QualType VecType;
1629  const VectorType *IVT = IType->getAs<VectorType>();
1630  unsigned numIElts = IVT->getNumElements();
1631 
1632  if (IType->isExtVectorType())
1633  VecType = SemaRef.Context.getExtVectorType(elementType, numIElts);
1634  else
1635  VecType = SemaRef.Context.getVectorType(elementType, numIElts,
1636  IVT->getVectorKind());
1637  CheckSubElementType(ElementEntity, IList, VecType, Index,
1638  StructuredList, StructuredIndex);
1639  numEltsInit += numIElts;
1640  }
1641  }
1642 
1643  // OpenCL requires all elements to be initialized.
1644  if (numEltsInit != maxElements) {
1645  if (!VerifyOnly)
1646  SemaRef.Diag(IList->getLocStart(),
1647  diag::err_vector_incorrect_num_initializers)
1648  << (numEltsInit < maxElements) << maxElements << numEltsInit;
1649  hadError = true;
1650  }
1651 }
1652 
1653 void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
1654  InitListExpr *IList, QualType &DeclType,
1655  llvm::APSInt elementIndex,
1656  bool SubobjectIsDesignatorContext,
1657  unsigned &Index,
1658  InitListExpr *StructuredList,
1659  unsigned &StructuredIndex) {
1660  const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType);
1661 
1662  // Check for the special-case of initializing an array with a string.
1663  if (Index < IList->getNumInits()) {
1664  if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) ==
1665  SIF_None) {
1666  // We place the string literal directly into the resulting
1667  // initializer list. This is the only place where the structure
1668  // of the structured initializer list doesn't match exactly,
1669  // because doing so would involve allocating one character
1670  // constant for each string.
1671  if (!VerifyOnly) {
1672  CheckStringInit(IList->getInit(Index), DeclType, arrayType, SemaRef);
1673  UpdateStructuredListElement(StructuredList, StructuredIndex,
1674  IList->getInit(Index));
1675  StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
1676  }
1677  ++Index;
1678  return;
1679  }
1680  }
1681  if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
1682  // Check for VLAs; in standard C it would be possible to check this
1683  // earlier, but I don't know where clang accepts VLAs (gcc accepts
1684  // them in all sorts of strange places).
1685  if (!VerifyOnly)
1686  SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
1687  diag::err_variable_object_no_init)
1688  << VAT->getSizeExpr()->getSourceRange();
1689  hadError = true;
1690  ++Index;
1691  ++StructuredIndex;
1692  return;
1693  }
1694 
1695  // We might know the maximum number of elements in advance.
1696  llvm::APSInt maxElements(elementIndex.getBitWidth(),
1697  elementIndex.isUnsigned());
1698  bool maxElementsKnown = false;
1699  if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) {
1700  maxElements = CAT->getSize();
1701  elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
1702  elementIndex.setIsUnsigned(maxElements.isUnsigned());
1703  maxElementsKnown = true;
1704  }
1705 
1706  QualType elementType = arrayType->getElementType();
1707  while (Index < IList->getNumInits()) {
1708  Expr *Init = IList->getInit(Index);
1709  if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1710  // If we're not the subobject that matches up with the '{' for
1711  // the designator, we shouldn't be handling the
1712  // designator. Return immediately.
1713  if (!SubobjectIsDesignatorContext)
1714  return;
1715 
1716  // Handle this designated initializer. elementIndex will be
1717  // updated to be the next array element we'll initialize.
1718  if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1719  DeclType, nullptr, &elementIndex, Index,
1720  StructuredList, StructuredIndex, true,
1721  false)) {
1722  hadError = true;
1723  continue;
1724  }
1725 
1726  if (elementIndex.getBitWidth() > maxElements.getBitWidth())
1727  maxElements = maxElements.extend(elementIndex.getBitWidth());
1728  else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
1729  elementIndex = elementIndex.extend(maxElements.getBitWidth());
1730  elementIndex.setIsUnsigned(maxElements.isUnsigned());
1731 
1732  // If the array is of incomplete type, keep track of the number of
1733  // elements in the initializer.
1734  if (!maxElementsKnown && elementIndex > maxElements)
1735  maxElements = elementIndex;
1736 
1737  continue;
1738  }
1739 
1740  // If we know the maximum number of elements, and we've already
1741  // hit it, stop consuming elements in the initializer list.
1742  if (maxElementsKnown && elementIndex == maxElements)
1743  break;
1744 
1745  InitializedEntity ElementEntity =
1746  InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
1747  Entity);
1748  // Check this element.
1749  CheckSubElementType(ElementEntity, IList, elementType, Index,
1750  StructuredList, StructuredIndex);
1751  ++elementIndex;
1752 
1753  // If the array is of incomplete type, keep track of the number of
1754  // elements in the initializer.
1755  if (!maxElementsKnown && elementIndex > maxElements)
1756  maxElements = elementIndex;
1757  }
1758  if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) {
1759  // If this is an incomplete array type, the actual type needs to
1760  // be calculated here.
1761  llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
1762  if (maxElements == Zero && !Entity.isVariableLengthArrayNew()) {
1763  // Sizing an array implicitly to zero is not allowed by ISO C,
1764  // but is supported by GNU.
1765  SemaRef.Diag(IList->getLocStart(),
1766  diag::ext_typecheck_zero_array_size);
1767  }
1768 
1769  DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
1770  ArrayType::Normal, 0);
1771  }
1772  if (!hadError && VerifyOnly) {
1773  // If there are any members of the array that get value-initialized, check
1774  // that is possible. That happens if we know the bound and don't have
1775  // enough elements, or if we're performing an array new with an unknown
1776  // bound.
1777  // FIXME: This needs to detect holes left by designated initializers too.
1778  if ((maxElementsKnown && elementIndex < maxElements) ||
1779  Entity.isVariableLengthArrayNew())
1780  CheckEmptyInitializable(InitializedEntity::InitializeElement(
1781  SemaRef.Context, 0, Entity),
1782  IList->getLocEnd());
1783  }
1784 }
1785 
1786 bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity,
1787  Expr *InitExpr,
1788  FieldDecl *Field,
1789  bool TopLevelObject) {
1790  // Handle GNU flexible array initializers.
1791  unsigned FlexArrayDiag;
1792  if (isa<InitListExpr>(InitExpr) &&
1793  cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
1794  // Empty flexible array init always allowed as an extension
1795  FlexArrayDiag = diag::ext_flexible_array_init;
1796  } else if (SemaRef.getLangOpts().CPlusPlus) {
1797  // Disallow flexible array init in C++; it is not required for gcc
1798  // compatibility, and it needs work to IRGen correctly in general.
1799  FlexArrayDiag = diag::err_flexible_array_init;
1800  } else if (!TopLevelObject) {
1801  // Disallow flexible array init on non-top-level object
1802  FlexArrayDiag = diag::err_flexible_array_init;
1803  } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
1804  // Disallow flexible array init on anything which is not a variable.
1805  FlexArrayDiag = diag::err_flexible_array_init;
1806  } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) {
1807  // Disallow flexible array init on local variables.
1808  FlexArrayDiag = diag::err_flexible_array_init;
1809  } else {
1810  // Allow other cases.
1811  FlexArrayDiag = diag::ext_flexible_array_init;
1812  }
1813 
1814  if (!VerifyOnly) {
1815  SemaRef.Diag(InitExpr->getLocStart(),
1816  FlexArrayDiag)
1817  << InitExpr->getLocStart();
1818  SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1819  << Field;
1820  }
1821 
1822  return FlexArrayDiag != diag::ext_flexible_array_init;
1823 }
1824 
1825 void InitListChecker::CheckStructUnionTypes(
1826  const InitializedEntity &Entity, InitListExpr *IList, QualType DeclType,
1828  bool SubobjectIsDesignatorContext, unsigned &Index,
1829  InitListExpr *StructuredList, unsigned &StructuredIndex,
1830  bool TopLevelObject) {
1831  RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
1832 
1833  // If the record is invalid, some of it's members are invalid. To avoid
1834  // confusion, we forgo checking the intializer for the entire record.
1835  if (structDecl->isInvalidDecl()) {
1836  // Assume it was supposed to consume a single initializer.
1837  ++Index;
1838  hadError = true;
1839  return;
1840  }
1841 
1842  if (DeclType->isUnionType() && IList->getNumInits() == 0) {
1843  RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1844 
1845  // If there's a default initializer, use it.
1846  if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
1847  if (VerifyOnly)
1848  return;
1849  for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1850  Field != FieldEnd; ++Field) {
1851  if (Field->hasInClassInitializer()) {
1852  StructuredList->setInitializedFieldInUnion(*Field);
1853  // FIXME: Actually build a CXXDefaultInitExpr?
1854  return;
1855  }
1856  }
1857  }
1858 
1859  // Value-initialize the first member of the union that isn't an unnamed
1860  // bitfield.
1861  for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1862  Field != FieldEnd; ++Field) {
1863  if (!Field->isUnnamedBitfield()) {
1864  if (VerifyOnly)
1865  CheckEmptyInitializable(
1866  InitializedEntity::InitializeMember(*Field, &Entity),
1867  IList->getLocEnd());
1868  else
1869  StructuredList->setInitializedFieldInUnion(*Field);
1870  break;
1871  }
1872  }
1873  return;
1874  }
1875 
1876  bool InitializedSomething = false;
1877 
1878  // If we have any base classes, they are initialized prior to the fields.
1879  for (auto &Base : Bases) {
1880  Expr *Init = Index < IList->getNumInits() ? IList->getInit(Index) : nullptr;
1881  SourceLocation InitLoc = Init ? Init->getLocStart() : IList->getLocEnd();
1882 
1883  // Designated inits always initialize fields, so if we see one, all
1884  // remaining base classes have no explicit initializer.
1885  if (Init && isa<DesignatedInitExpr>(Init))
1886  Init = nullptr;
1887 
1889  SemaRef.Context, &Base, false, &Entity);
1890  if (Init) {
1891  CheckSubElementType(BaseEntity, IList, Base.getType(), Index,
1892  StructuredList, StructuredIndex);
1893  InitializedSomething = true;
1894  } else if (VerifyOnly) {
1895  CheckEmptyInitializable(BaseEntity, InitLoc);
1896  }
1897  }
1898 
1899  // If structDecl is a forward declaration, this loop won't do
1900  // anything except look at designated initializers; That's okay,
1901  // because an error should get printed out elsewhere. It might be
1902  // worthwhile to skip over the rest of the initializer, though.
1903  RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1904  RecordDecl::field_iterator FieldEnd = RD->field_end();
1905  bool CheckForMissingFields =
1906  !IList->isIdiomaticZeroInitializer(SemaRef.getLangOpts());
1907 
1908  while (Index < IList->getNumInits()) {
1909  Expr *Init = IList->getInit(Index);
1910 
1911  if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1912  // If we're not the subobject that matches up with the '{' for
1913  // the designator, we shouldn't be handling the
1914  // designator. Return immediately.
1915  if (!SubobjectIsDesignatorContext)
1916  return;
1917 
1918  // Handle this designated initializer. Field will be updated to
1919  // the next field that we'll be initializing.
1920  if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1921  DeclType, &Field, nullptr, Index,
1922  StructuredList, StructuredIndex,
1923  true, TopLevelObject))
1924  hadError = true;
1925 
1926  InitializedSomething = true;
1927 
1928  // Disable check for missing fields when designators are used.
1929  // This matches gcc behaviour.
1930  CheckForMissingFields = false;
1931  continue;
1932  }
1933 
1934  if (Field == FieldEnd) {
1935  // We've run out of fields. We're done.
1936  break;
1937  }
1938 
1939  // We've already initialized a member of a union. We're done.
1940  if (InitializedSomething && DeclType->isUnionType())
1941  break;
1942 
1943  // If we've hit the flexible array member at the end, we're done.
1944  if (Field->getType()->isIncompleteArrayType())
1945  break;
1946 
1947  if (Field->isUnnamedBitfield()) {
1948  // Don't initialize unnamed bitfields, e.g. "int : 20;"
1949  ++Field;
1950  continue;
1951  }
1952 
1953  // Make sure we can use this declaration.
1954  bool InvalidUse;
1955  if (VerifyOnly)
1956  InvalidUse = !SemaRef.CanUseDecl(*Field, TreatUnavailableAsInvalid);
1957  else
1958  InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field,
1959  IList->getInit(Index)->getLocStart());
1960  if (InvalidUse) {
1961  ++Index;
1962  ++Field;
1963  hadError = true;
1964  continue;
1965  }
1966 
1967  InitializedEntity MemberEntity =
1968  InitializedEntity::InitializeMember(*Field, &Entity);
1969  CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1970  StructuredList, StructuredIndex);
1971  InitializedSomething = true;
1972 
1973  if (DeclType->isUnionType() && !VerifyOnly) {
1974  // Initialize the first field within the union.
1975  StructuredList->setInitializedFieldInUnion(*Field);
1976  }
1977 
1978  ++Field;
1979  }
1980 
1981  // Emit warnings for missing struct field initializers.
1982  if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
1983  Field != FieldEnd && !Field->getType()->isIncompleteArrayType() &&
1984  !DeclType->isUnionType()) {
1985  // It is possible we have one or more unnamed bitfields remaining.
1986  // Find first (if any) named field and emit warning.
1987  for (RecordDecl::field_iterator it = Field, end = RD->field_end();
1988  it != end; ++it) {
1989  if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) {
1990  SemaRef.Diag(IList->getSourceRange().getEnd(),
1991  diag::warn_missing_field_initializers) << *it;
1992  break;
1993  }
1994  }
1995  }
1996 
1997  // Check that any remaining fields can be value-initialized.
1998  if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() &&
1999  !Field->getType()->isIncompleteArrayType()) {
2000  // FIXME: Should check for holes left by designated initializers too.
2001  for (; Field != FieldEnd && !hadError; ++Field) {
2002  if (!Field->isUnnamedBitfield() && !Field->hasInClassInitializer())
2003  CheckEmptyInitializable(
2004  InitializedEntity::InitializeMember(*Field, &Entity),
2005  IList->getLocEnd());
2006  }
2007  }
2008 
2009  if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
2010  Index >= IList->getNumInits())
2011  return;
2012 
2013  if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field,
2014  TopLevelObject)) {
2015  hadError = true;
2016  ++Index;
2017  return;
2018  }
2019 
2020  InitializedEntity MemberEntity =
2021  InitializedEntity::InitializeMember(*Field, &Entity);
2022 
2023  if (isa<InitListExpr>(IList->getInit(Index)))
2024  CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
2025  StructuredList, StructuredIndex);
2026  else
2027  CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
2028  StructuredList, StructuredIndex);
2029 }
2030 
2031 /// Expand a field designator that refers to a member of an
2032 /// anonymous struct or union into a series of field designators that
2033 /// refers to the field within the appropriate subobject.
2034 ///
2036  DesignatedInitExpr *DIE,
2037  unsigned DesigIdx,
2038  IndirectFieldDecl *IndirectField) {
2040 
2041  // Build the replacement designators.
2042  SmallVector<Designator, 4> Replacements;
2043  for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
2044  PE = IndirectField->chain_end(); PI != PE; ++PI) {
2045  if (PI + 1 == PE)
2046  Replacements.push_back(Designator((IdentifierInfo *)nullptr,
2047  DIE->getDesignator(DesigIdx)->getDotLoc(),
2048  DIE->getDesignator(DesigIdx)->getFieldLoc()));
2049  else
2050  Replacements.push_back(Designator((IdentifierInfo *)nullptr,
2052  assert(isa<FieldDecl>(*PI));
2053  Replacements.back().setField(cast<FieldDecl>(*PI));
2054  }
2055 
2056  // Expand the current designator into the set of replacement
2057  // designators, so we have a full subobject path down to where the
2058  // member of the anonymous struct/union is actually stored.
2059  DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
2060  &Replacements[0] + Replacements.size());
2061 }
2062 
2064  DesignatedInitExpr *DIE) {
2065  unsigned NumIndexExprs = DIE->getNumSubExprs() - 1;
2066  SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
2067  for (unsigned I = 0; I < NumIndexExprs; ++I)
2068  IndexExprs[I] = DIE->getSubExpr(I + 1);
2069  return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators(),
2070  IndexExprs,
2071  DIE->getEqualOrColonLoc(),
2072  DIE->usesGNUSyntax(), DIE->getInit());
2073 }
2074 
2075 namespace {
2076 
2077 // Callback to only accept typo corrections that are for field members of
2078 // the given struct or union.
2079 class FieldInitializerValidatorCCC : public CorrectionCandidateCallback {
2080  public:
2081  explicit FieldInitializerValidatorCCC(RecordDecl *RD)
2082  : Record(RD) {}
2083 
2084  bool ValidateCandidate(const TypoCorrection &candidate) override {
2085  FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>();
2086  return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record);
2087  }
2088 
2089  private:
2090  RecordDecl *Record;
2091 };
2092 
2093 } // end anonymous namespace
2094 
2095 /// Check the well-formedness of a C99 designated initializer.
2096 ///
2097 /// Determines whether the designated initializer @p DIE, which
2098 /// resides at the given @p Index within the initializer list @p
2099 /// IList, is well-formed for a current object of type @p DeclType
2100 /// (C99 6.7.8). The actual subobject that this designator refers to
2101 /// within the current subobject is returned in either
2102 /// @p NextField or @p NextElementIndex (whichever is appropriate).
2103 ///
2104 /// @param IList The initializer list in which this designated
2105 /// initializer occurs.
2106 ///
2107 /// @param DIE The designated initializer expression.
2108 ///
2109 /// @param DesigIdx The index of the current designator.
2110 ///
2111 /// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
2112 /// into which the designation in @p DIE should refer.
2113 ///
2114 /// @param NextField If non-NULL and the first designator in @p DIE is
2115 /// a field, this will be set to the field declaration corresponding
2116 /// to the field named by the designator.
2117 ///
2118 /// @param NextElementIndex If non-NULL and the first designator in @p
2119 /// DIE is an array designator or GNU array-range designator, this
2120 /// will be set to the last index initialized by this designator.
2121 ///
2122 /// @param Index Index into @p IList where the designated initializer
2123 /// @p DIE occurs.
2124 ///
2125 /// @param StructuredList The initializer list expression that
2126 /// describes all of the subobject initializers in the order they'll
2127 /// actually be initialized.
2128 ///
2129 /// @returns true if there was an error, false otherwise.
2130 bool
2131 InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
2132  InitListExpr *IList,
2133  DesignatedInitExpr *DIE,
2134  unsigned DesigIdx,
2135  QualType &CurrentObjectType,
2136  RecordDecl::field_iterator *NextField,
2137  llvm::APSInt *NextElementIndex,
2138  unsigned &Index,
2139  InitListExpr *StructuredList,
2140  unsigned &StructuredIndex,
2141  bool FinishSubobjectInit,
2142  bool TopLevelObject) {
2143  if (DesigIdx == DIE->size()) {
2144  // Check the actual initialization for the designated object type.
2145  bool prevHadError = hadError;
2146 
2147  // Temporarily remove the designator expression from the
2148  // initializer list that the child calls see, so that we don't try
2149  // to re-process the designator.
2150  unsigned OldIndex = Index;
2151  IList->setInit(OldIndex, DIE->getInit());
2152 
2153  CheckSubElementType(Entity, IList, CurrentObjectType, Index,
2154  StructuredList, StructuredIndex);
2155 
2156  // Restore the designated initializer expression in the syntactic
2157  // form of the initializer list.
2158  if (IList->getInit(OldIndex) != DIE->getInit())
2159  DIE->setInit(IList->getInit(OldIndex));
2160  IList->setInit(OldIndex, DIE);
2161 
2162  return hadError && !prevHadError;
2163  }
2164 
2165  DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
2166  bool IsFirstDesignator = (DesigIdx == 0);
2167  if (!VerifyOnly) {
2168  assert((IsFirstDesignator || StructuredList) &&
2169  "Need a non-designated initializer list to start from");
2170 
2171  // Determine the structural initializer list that corresponds to the
2172  // current subobject.
2173  if (IsFirstDesignator)
2174  StructuredList = SyntacticToSemantic.lookup(IList);
2175  else {
2176  Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2177  StructuredList->getInit(StructuredIndex) : nullptr;
2178  if (!ExistingInit && StructuredList->hasArrayFiller())
2179  ExistingInit = StructuredList->getArrayFiller();
2180 
2181  if (!ExistingInit)
2182  StructuredList =
2183  getStructuredSubobjectInit(IList, Index, CurrentObjectType,
2184  StructuredList, StructuredIndex,
2185  SourceRange(D->getLocStart(),
2186  DIE->getLocEnd()));
2187  else if (InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2188  StructuredList = Result;
2189  else {
2190  if (DesignatedInitUpdateExpr *E =
2191  dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2192  StructuredList = E->getUpdater();
2193  else {
2194  DesignatedInitUpdateExpr *DIUE =
2195  new (SemaRef.Context) DesignatedInitUpdateExpr(SemaRef.Context,
2196  D->getLocStart(), ExistingInit,
2197  DIE->getLocEnd());
2198  StructuredList->updateInit(SemaRef.Context, StructuredIndex, DIUE);
2199  StructuredList = DIUE->getUpdater();
2200  }
2201 
2202  // We need to check on source range validity because the previous
2203  // initializer does not have to be an explicit initializer. e.g.,
2204  //
2205  // struct P { int a, b; };
2206  // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2207  //
2208  // There is an overwrite taking place because the first braced initializer
2209  // list "{ .a = 2 }" already provides value for .p.b (which is zero).
2210  if (ExistingInit->getSourceRange().isValid()) {
2211  // We are creating an initializer list that initializes the
2212  // subobjects of the current object, but there was already an
2213  // initialization that completely initialized the current
2214  // subobject, e.g., by a compound literal:
2215  //
2216  // struct X { int a, b; };
2217  // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2218  //
2219  // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2220  // designated initializer re-initializes the whole
2221  // subobject [0], overwriting previous initializers.
2222  SemaRef.Diag(D->getLocStart(),
2223  diag::warn_subobject_initializer_overrides)
2224  << SourceRange(D->getLocStart(), DIE->getLocEnd());
2225 
2226  SemaRef.Diag(ExistingInit->getLocStart(),
2227  diag::note_previous_initializer)
2228  << /*FIXME:has side effects=*/0
2229  << ExistingInit->getSourceRange();
2230  }
2231  }
2232  }
2233  assert(StructuredList && "Expected a structured initializer list");
2234  }
2235 
2236  if (D->isFieldDesignator()) {
2237  // C99 6.7.8p7:
2238  //
2239  // If a designator has the form
2240  //
2241  // . identifier
2242  //
2243  // then the current object (defined below) shall have
2244  // structure or union type and the identifier shall be the
2245  // name of a member of that type.
2246  const RecordType *RT = CurrentObjectType->getAs<RecordType>();
2247  if (!RT) {
2248  SourceLocation Loc = D->getDotLoc();
2249  if (Loc.isInvalid())
2250  Loc = D->getFieldLoc();
2251  if (!VerifyOnly)
2252  SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
2253  << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
2254  ++Index;
2255  return true;
2256  }
2257 
2258  FieldDecl *KnownField = D->getField();
2259  if (!KnownField) {
2260  IdentifierInfo *FieldName = D->getFieldName();
2261  DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
2262  for (NamedDecl *ND : Lookup) {
2263  if (auto *FD = dyn_cast<FieldDecl>(ND)) {
2264  KnownField = FD;
2265  break;
2266  }
2267  if (auto *IFD = dyn_cast<IndirectFieldDecl>(ND)) {
2268  // In verify mode, don't modify the original.
2269  if (VerifyOnly)
2270  DIE = CloneDesignatedInitExpr(SemaRef, DIE);
2271  ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IFD);
2272  D = DIE->getDesignator(DesigIdx);
2273  KnownField = cast<FieldDecl>(*IFD->chain_begin());
2274  break;
2275  }
2276  }
2277  if (!KnownField) {
2278  if (VerifyOnly) {
2279  ++Index;
2280  return true; // No typo correction when just trying this out.
2281  }
2282 
2283  // Name lookup found something, but it wasn't a field.
2284  if (!Lookup.empty()) {
2285  SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
2286  << FieldName;
2287  SemaRef.Diag(Lookup.front()->getLocation(),
2288  diag::note_field_designator_found);
2289  ++Index;
2290  return true;
2291  }
2292 
2293  // Name lookup didn't find anything.
2294  // Determine whether this was a typo for another field name.
2295  if (TypoCorrection Corrected = SemaRef.CorrectTypo(
2296  DeclarationNameInfo(FieldName, D->getFieldLoc()),
2297  Sema::LookupMemberName, /*Scope=*/nullptr, /*SS=*/nullptr,
2298  llvm::make_unique<FieldInitializerValidatorCCC>(RT->getDecl()),
2299  Sema::CTK_ErrorRecovery, RT->getDecl())) {
2300  SemaRef.diagnoseTypo(
2301  Corrected,
2302  SemaRef.PDiag(diag::err_field_designator_unknown_suggest)
2303  << FieldName << CurrentObjectType);
2304  KnownField = Corrected.getCorrectionDeclAs<FieldDecl>();
2305  hadError = true;
2306  } else {
2307  // Typo correction didn't find anything.
2308  SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
2309  << FieldName << CurrentObjectType;
2310  ++Index;
2311  return true;
2312  }
2313  }
2314  }
2315 
2316  unsigned FieldIndex = 0;
2317 
2318  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
2319  FieldIndex = CXXRD->getNumBases();
2320 
2321  for (auto *FI : RT->getDecl()->fields()) {
2322  if (FI->isUnnamedBitfield())
2323  continue;
2324  if (declaresSameEntity(KnownField, FI)) {
2325  KnownField = FI;
2326  break;
2327  }
2328  ++FieldIndex;
2329  }
2330 
2333 
2334  // All of the fields of a union are located at the same place in
2335  // the initializer list.
2336  if (RT->getDecl()->isUnion()) {
2337  FieldIndex = 0;
2338  if (!VerifyOnly) {
2339  FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2340  if (CurrentField && !declaresSameEntity(CurrentField, *Field)) {
2341  assert(StructuredList->getNumInits() == 1
2342  && "A union should never have more than one initializer!");
2343 
2344  Expr *ExistingInit = StructuredList->getInit(0);
2345  if (ExistingInit) {
2346  // We're about to throw away an initializer, emit warning.
2347  SemaRef.Diag(D->getFieldLoc(),
2348  diag::warn_initializer_overrides)
2349  << D->getSourceRange();
2350  SemaRef.Diag(ExistingInit->getLocStart(),
2351  diag::note_previous_initializer)
2352  << /*FIXME:has side effects=*/0
2353  << ExistingInit->getSourceRange();
2354  }
2355 
2356  // remove existing initializer
2357  StructuredList->resizeInits(SemaRef.Context, 0);
2358  StructuredList->setInitializedFieldInUnion(nullptr);
2359  }
2360 
2361  StructuredList->setInitializedFieldInUnion(*Field);
2362  }
2363  }
2364 
2365  // Make sure we can use this declaration.
2366  bool InvalidUse;
2367  if (VerifyOnly)
2368  InvalidUse = !SemaRef.CanUseDecl(*Field, TreatUnavailableAsInvalid);
2369  else
2370  InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
2371  if (InvalidUse) {
2372  ++Index;
2373  return true;
2374  }
2375 
2376  if (!VerifyOnly) {
2377  // Update the designator with the field declaration.
2378  D->setField(*Field);
2379 
2380  // Make sure that our non-designated initializer list has space
2381  // for a subobject corresponding to this field.
2382  if (FieldIndex >= StructuredList->getNumInits())
2383  StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
2384  }
2385 
2386  // This designator names a flexible array member.
2387  if (Field->getType()->isIncompleteArrayType()) {
2388  bool Invalid = false;
2389  if ((DesigIdx + 1) != DIE->size()) {
2390  // We can't designate an object within the flexible array
2391  // member (because GCC doesn't allow it).
2392  if (!VerifyOnly) {
2394  = DIE->getDesignator(DesigIdx + 1);
2395  SemaRef.Diag(NextD->getLocStart(),
2396  diag::err_designator_into_flexible_array_member)
2397  << SourceRange(NextD->getLocStart(),
2398  DIE->getLocEnd());
2399  SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2400  << *Field;
2401  }
2402  Invalid = true;
2403  }
2404 
2405  if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
2406  !isa<StringLiteral>(DIE->getInit())) {
2407  // The initializer is not an initializer list.
2408  if (!VerifyOnly) {
2409  SemaRef.Diag(DIE->getInit()->getLocStart(),
2410  diag::err_flexible_array_init_needs_braces)
2411  << DIE->getInit()->getSourceRange();
2412  SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2413  << *Field;
2414  }
2415  Invalid = true;
2416  }
2417 
2418  // Check GNU flexible array initializer.
2419  if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
2420  TopLevelObject))
2421  Invalid = true;
2422 
2423  if (Invalid) {
2424  ++Index;
2425  return true;
2426  }
2427 
2428  // Initialize the array.
2429  bool prevHadError = hadError;
2430  unsigned newStructuredIndex = FieldIndex;
2431  unsigned OldIndex = Index;
2432  IList->setInit(Index, DIE->getInit());
2433 
2434  InitializedEntity MemberEntity =
2435  InitializedEntity::InitializeMember(*Field, &Entity);
2436  CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
2437  StructuredList, newStructuredIndex);
2438 
2439  IList->setInit(OldIndex, DIE);
2440  if (hadError && !prevHadError) {
2441  ++Field;
2442  ++FieldIndex;
2443  if (NextField)
2444  *NextField = Field;
2445  StructuredIndex = FieldIndex;
2446  return true;
2447  }
2448  } else {
2449  // Recurse to check later designated subobjects.
2450  QualType FieldType = Field->getType();
2451  unsigned newStructuredIndex = FieldIndex;
2452 
2453  InitializedEntity MemberEntity =
2454  InitializedEntity::InitializeMember(*Field, &Entity);
2455  if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2456  FieldType, nullptr, nullptr, Index,
2457  StructuredList, newStructuredIndex,
2458  FinishSubobjectInit, false))
2459  return true;
2460  }
2461 
2462  // Find the position of the next field to be initialized in this
2463  // subobject.
2464  ++Field;
2465  ++FieldIndex;
2466 
2467  // If this the first designator, our caller will continue checking
2468  // the rest of this struct/class/union subobject.
2469  if (IsFirstDesignator) {
2470  if (NextField)
2471  *NextField = Field;
2472  StructuredIndex = FieldIndex;
2473  return false;
2474  }
2475 
2476  if (!FinishSubobjectInit)
2477  return false;
2478 
2479  // We've already initialized something in the union; we're done.
2480  if (RT->getDecl()->isUnion())
2481  return hadError;
2482 
2483  // Check the remaining fields within this class/struct/union subobject.
2484  bool prevHadError = hadError;
2485 
2486  auto NoBases =
2489  CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,
2490  false, Index, StructuredList, FieldIndex);
2491  return hadError && !prevHadError;
2492  }
2493 
2494  // C99 6.7.8p6:
2495  //
2496  // If a designator has the form
2497  //
2498  // [ constant-expression ]
2499  //
2500  // then the current object (defined below) shall have array
2501  // type and the expression shall be an integer constant
2502  // expression. If the array is of unknown size, any
2503  // nonnegative value is valid.
2504  //
2505  // Additionally, cope with the GNU extension that permits
2506  // designators of the form
2507  //
2508  // [ constant-expression ... constant-expression ]
2509  const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
2510  if (!AT) {
2511  if (!VerifyOnly)
2512  SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
2513  << CurrentObjectType;
2514  ++Index;
2515  return true;
2516  }
2517 
2518  Expr *IndexExpr = nullptr;
2519  llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2520  if (D->isArrayDesignator()) {
2521  IndexExpr = DIE->getArrayIndex(*D);
2522  DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
2523  DesignatedEndIndex = DesignatedStartIndex;
2524  } else {
2525  assert(D->isArrayRangeDesignator() && "Need array-range designator");
2526 
2527  DesignatedStartIndex =
2529  DesignatedEndIndex =
2530  DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
2531  IndexExpr = DIE->getArrayRangeEnd(*D);
2532 
2533  // Codegen can't handle evaluating array range designators that have side
2534  // effects, because we replicate the AST value for each initialized element.
2535  // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
2536  // elements with something that has a side effect, so codegen can emit an
2537  // "error unsupported" error instead of miscompiling the app.
2538  if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
2539  DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
2540  FullyStructuredList->sawArrayRangeDesignator();
2541  }
2542 
2543  if (isa<ConstantArrayType>(AT)) {
2544  llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
2545  DesignatedStartIndex
2546  = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
2547  DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
2548  DesignatedEndIndex
2549  = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
2550  DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2551  if (DesignatedEndIndex >= MaxElements) {
2552  if (!VerifyOnly)
2553  SemaRef.Diag(IndexExpr->getLocStart(),
2554  diag::err_array_designator_too_large)
2555  << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
2556  << IndexExpr->getSourceRange();
2557  ++Index;
2558  return true;
2559  }
2560  } else {
2561  unsigned DesignatedIndexBitWidth =
2563  DesignatedStartIndex =
2564  DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
2565  DesignatedEndIndex =
2566  DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
2567  DesignatedStartIndex.setIsUnsigned(true);
2568  DesignatedEndIndex.setIsUnsigned(true);
2569  }
2570 
2571  if (!VerifyOnly && StructuredList->isStringLiteralInit()) {
2572  // We're modifying a string literal init; we have to decompose the string
2573  // so we can modify the individual characters.
2574  ASTContext &Context = SemaRef.Context;
2575  Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2576 
2577  // Compute the character type
2578  QualType CharTy = AT->getElementType();
2579 
2580  // Compute the type of the integer literals.
2581  QualType PromotedCharTy = CharTy;
2582  if (CharTy->isPromotableIntegerType())
2583  PromotedCharTy = Context.getPromotedIntegerType(CharTy);
2584  unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
2585 
2586  if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
2587  // Get the length of the string.
2588  uint64_t StrLen = SL->getLength();
2589  if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2590  StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2591  StructuredList->resizeInits(Context, StrLen);
2592 
2593  // Build a literal for each character in the string, and put them into
2594  // the init list.
2595  for (unsigned i = 0, e = StrLen; i != e; ++i) {
2596  llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2597  Expr *Init = new (Context) IntegerLiteral(
2598  Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2599  if (CharTy != PromotedCharTy)
2600  Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2601  Init, nullptr, VK_RValue);
2602  StructuredList->updateInit(Context, i, Init);
2603  }
2604  } else {
2605  ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
2606  std::string Str;
2607  Context.getObjCEncodingForType(E->getEncodedType(), Str);
2608 
2609  // Get the length of the string.
2610  uint64_t StrLen = Str.size();
2611  if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2612  StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2613  StructuredList->resizeInits(Context, StrLen);
2614 
2615  // Build a literal for each character in the string, and put them into
2616  // the init list.
2617  for (unsigned i = 0, e = StrLen; i != e; ++i) {
2618  llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2619  Expr *Init = new (Context) IntegerLiteral(
2620  Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2621  if (CharTy != PromotedCharTy)
2622  Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2623  Init, nullptr, VK_RValue);
2624  StructuredList->updateInit(Context, i, Init);
2625  }
2626  }
2627  }
2628 
2629  // Make sure that our non-designated initializer list has space
2630  // for a subobject corresponding to this array element.
2631  if (!VerifyOnly &&
2632  DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
2633  StructuredList->resizeInits(SemaRef.Context,
2634  DesignatedEndIndex.getZExtValue() + 1);
2635 
2636  // Repeatedly perform subobject initializations in the range
2637  // [DesignatedStartIndex, DesignatedEndIndex].
2638 
2639  // Move to the next designator
2640  unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
2641  unsigned OldIndex = Index;
2642 
2643  InitializedEntity ElementEntity =
2644  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
2645 
2646  while (DesignatedStartIndex <= DesignatedEndIndex) {
2647  // Recurse to check later designated subobjects.
2648  QualType ElementType = AT->getElementType();
2649  Index = OldIndex;
2650 
2651  ElementEntity.setElementIndex(ElementIndex);
2652  if (CheckDesignatedInitializer(
2653  ElementEntity, IList, DIE, DesigIdx + 1, ElementType, nullptr,
2654  nullptr, Index, StructuredList, ElementIndex,
2655  FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),
2656  false))
2657  return true;
2658 
2659  // Move to the next index in the array that we'll be initializing.
2660  ++DesignatedStartIndex;
2661  ElementIndex = DesignatedStartIndex.getZExtValue();
2662  }
2663 
2664  // If this the first designator, our caller will continue checking
2665  // the rest of this array subobject.
2666  if (IsFirstDesignator) {
2667  if (NextElementIndex)
2668  *NextElementIndex = DesignatedStartIndex;
2669  StructuredIndex = ElementIndex;
2670  return false;
2671  }
2672 
2673  if (!FinishSubobjectInit)
2674  return false;
2675 
2676  // Check the remaining elements within this array subobject.
2677  bool prevHadError = hadError;
2678  CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
2679  /*SubobjectIsDesignatorContext=*/false, Index,
2680  StructuredList, ElementIndex);
2681  return hadError && !prevHadError;
2682 }
2683 
2684 // Get the structured initializer list for a subobject of type
2685 // @p CurrentObjectType.
2686 InitListExpr *
2687 InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2688  QualType CurrentObjectType,
2689  InitListExpr *StructuredList,
2690  unsigned StructuredIndex,
2691  SourceRange InitRange,
2692  bool IsFullyOverwritten) {
2693  if (VerifyOnly)
2694  return nullptr; // No structured list in verification-only mode.
2695  Expr *ExistingInit = nullptr;
2696  if (!StructuredList)
2697  ExistingInit = SyntacticToSemantic.lookup(IList);
2698  else if (StructuredIndex < StructuredList->getNumInits())
2699  ExistingInit = StructuredList->getInit(StructuredIndex);
2700 
2701  if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2702  // There might have already been initializers for subobjects of the current
2703  // object, but a subsequent initializer list will overwrite the entirety
2704  // of the current object. (See DR 253 and C99 6.7.8p21). e.g.,
2705  //
2706  // struct P { char x[6]; };
2707  // struct P l = { .x[2] = 'x', .x = { [0] = 'f' } };
2708  //
2709  // The first designated initializer is ignored, and l.x is just "f".
2710  if (!IsFullyOverwritten)
2711  return Result;
2712 
2713  if (ExistingInit) {
2714  // We are creating an initializer list that initializes the
2715  // subobjects of the current object, but there was already an
2716  // initialization that completely initialized the current
2717  // subobject, e.g., by a compound literal:
2718  //
2719  // struct X { int a, b; };
2720  // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2721  //
2722  // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2723  // designated initializer re-initializes the whole
2724  // subobject [0], overwriting previous initializers.
2725  SemaRef.Diag(InitRange.getBegin(),
2726  diag::warn_subobject_initializer_overrides)
2727  << InitRange;
2728  SemaRef.Diag(ExistingInit->getLocStart(),
2729  diag::note_previous_initializer)
2730  << /*FIXME:has side effects=*/0
2731  << ExistingInit->getSourceRange();
2732  }
2733 
2735  = new (SemaRef.Context) InitListExpr(SemaRef.Context,
2736  InitRange.getBegin(), None,
2737  InitRange.getEnd());
2738 
2739  QualType ResultType = CurrentObjectType;
2740  if (!ResultType->isArrayType())
2741  ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2742  Result->setType(ResultType);
2743 
2744  // Pre-allocate storage for the structured initializer list.
2745  unsigned NumElements = 0;
2746  unsigned NumInits = 0;
2747  bool GotNumInits = false;
2748  if (!StructuredList) {
2749  NumInits = IList->getNumInits();
2750  GotNumInits = true;
2751  } else if (Index < IList->getNumInits()) {
2752  if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
2753  NumInits = SubList->getNumInits();
2754  GotNumInits = true;
2755  }
2756  }
2757 
2758  if (const ArrayType *AType
2759  = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2760  if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2761  NumElements = CAType->getSize().getZExtValue();
2762  // Simple heuristic so that we don't allocate a very large
2763  // initializer with many empty entries at the end.
2764  if (GotNumInits && NumElements > NumInits)
2765  NumElements = 0;
2766  }
2767  } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
2768  NumElements = VType->getNumElements();
2769  else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
2770  RecordDecl *RDecl = RType->getDecl();
2771  if (RDecl->isUnion())
2772  NumElements = 1;
2773  else
2774  NumElements = std::distance(RDecl->field_begin(), RDecl->field_end());
2775  }
2776 
2777  Result->reserveInits(SemaRef.Context, NumElements);
2778 
2779  // Link this new initializer list into the structured initializer
2780  // lists.
2781  if (StructuredList)
2782  StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
2783  else {
2784  Result->setSyntacticForm(IList);
2785  SyntacticToSemantic[IList] = Result;
2786  }
2787 
2788  return Result;
2789 }
2790 
2791 /// Update the initializer at index @p StructuredIndex within the
2792 /// structured initializer list to the value @p expr.
2793 void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2794  unsigned &StructuredIndex,
2795  Expr *expr) {
2796  // No structured initializer list to update
2797  if (!StructuredList)
2798  return;
2799 
2800  if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2801  StructuredIndex, expr)) {
2802  // This initializer overwrites a previous initializer. Warn.
2803  // We need to check on source range validity because the previous
2804  // initializer does not have to be an explicit initializer.
2805  // struct P { int a, b; };
2806  // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2807  // There is an overwrite taking place because the first braced initializer
2808  // list "{ .a = 2 }' already provides value for .p.b (which is zero).
2809  if (PrevInit->getSourceRange().isValid()) {
2810  SemaRef.Diag(expr->getLocStart(),
2811  diag::warn_initializer_overrides)
2812  << expr->getSourceRange();
2813 
2814  SemaRef.Diag(PrevInit->getLocStart(),
2815  diag::note_previous_initializer)
2816  << /*FIXME:has side effects=*/0
2817  << PrevInit->getSourceRange();
2818  }
2819  }
2820 
2821  ++StructuredIndex;
2822 }
2823 
2824 /// Check that the given Index expression is a valid array designator
2825 /// value. This is essentially just a wrapper around
2826 /// VerifyIntegerConstantExpression that also checks for negative values
2827 /// and produces a reasonable diagnostic if there is a
2828 /// failure. Returns the index expression, possibly with an implicit cast
2829 /// added, on success. If everything went okay, Value will receive the
2830 /// value of the constant expression.
2831 static ExprResult
2832 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
2833  SourceLocation Loc = Index->getLocStart();
2834 
2835  // Make sure this is an integer constant expression.
2837  if (Result.isInvalid())
2838  return Result;
2839 
2840  if (Value.isSigned() && Value.isNegative())
2841  return S.Diag(Loc, diag::err_array_designator_negative)
2842  << Value.toString(10) << Index->getSourceRange();
2843 
2844  Value.setIsUnsigned(true);
2845  return Result;
2846 }
2847 
2849  SourceLocation Loc,
2850  bool GNUSyntax,
2851  ExprResult Init) {
2852  typedef DesignatedInitExpr::Designator ASTDesignator;
2853 
2854  bool Invalid = false;
2855  SmallVector<ASTDesignator, 32> Designators;
2856  SmallVector<Expr *, 32> InitExpressions;
2857 
2858  // Build designators and check array designator expressions.
2859  for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2860  const Designator &D = Desig.getDesignator(Idx);
2861  switch (D.getKind()) {
2863  Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
2864  D.getFieldLoc()));
2865  break;
2866 
2868  Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2869  llvm::APSInt IndexValue;
2870  if (!Index->isTypeDependent() && !Index->isValueDependent())
2871  Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get();
2872  if (!Index)
2873  Invalid = true;
2874  else {
2875  Designators.push_back(ASTDesignator(InitExpressions.size(),
2876  D.getLBracketLoc(),
2877  D.getRBracketLoc()));
2878  InitExpressions.push_back(Index);
2879  }
2880  break;
2881  }
2882 
2884  Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
2885  Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
2886  llvm::APSInt StartValue;
2887  llvm::APSInt EndValue;
2888  bool StartDependent = StartIndex->isTypeDependent() ||
2889  StartIndex->isValueDependent();
2890  bool EndDependent = EndIndex->isTypeDependent() ||
2891  EndIndex->isValueDependent();
2892  if (!StartDependent)
2893  StartIndex =
2894  CheckArrayDesignatorExpr(*this, StartIndex, StartValue).get();
2895  if (!EndDependent)
2896  EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).get();
2897 
2898  if (!StartIndex || !EndIndex)
2899  Invalid = true;
2900  else {
2901  // Make sure we're comparing values with the same bit width.
2902  if (StartDependent || EndDependent) {
2903  // Nothing to compute.
2904  } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
2905  EndValue = EndValue.extend(StartValue.getBitWidth());
2906  else if (StartValue.getBitWidth() < EndValue.getBitWidth())
2907  StartValue = StartValue.extend(EndValue.getBitWidth());
2908 
2909  if (!StartDependent && !EndDependent && EndValue < StartValue) {
2910  Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
2911  << StartValue.toString(10) << EndValue.toString(10)
2912  << StartIndex->getSourceRange() << EndIndex->getSourceRange();
2913  Invalid = true;
2914  } else {
2915  Designators.push_back(ASTDesignator(InitExpressions.size(),
2916  D.getLBracketLoc(),
2917  D.getEllipsisLoc(),
2918  D.getRBracketLoc()));
2919  InitExpressions.push_back(StartIndex);
2920  InitExpressions.push_back(EndIndex);
2921  }
2922  }
2923  break;
2924  }
2925  }
2926  }
2927 
2928  if (Invalid || Init.isInvalid())
2929  return ExprError();
2930 
2931  // Clear out the expressions within the designation.
2932  Desig.ClearExprs(*this);
2933 
2934  DesignatedInitExpr *DIE
2935  = DesignatedInitExpr::Create(Context,
2936  Designators,
2937  InitExpressions, Loc, GNUSyntax,
2938  Init.getAs<Expr>());
2939 
2940  if (!getLangOpts().C99)
2941  Diag(DIE->getLocStart(), diag::ext_designated_init)
2942  << DIE->getSourceRange();
2943 
2944  return DIE;
2945 }
2946 
2947 //===----------------------------------------------------------------------===//
2948 // Initialization entity
2949 //===----------------------------------------------------------------------===//
2950 
2951 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
2952  const InitializedEntity &Parent)
2953  : Parent(&Parent), Index(Index)
2954 {
2955  if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
2956  Kind = EK_ArrayElement;
2957  Type = AT->getElementType();
2958  } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
2959  Kind = EK_VectorElement;
2960  Type = VT->getElementType();
2961  } else {
2962  const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
2963  assert(CT && "Unexpected type");
2964  Kind = EK_ComplexElement;
2965  Type = CT->getElementType();
2966  }
2967 }
2968 
2971  const CXXBaseSpecifier *Base,
2972  bool IsInheritedVirtualBase,
2973  const InitializedEntity *Parent) {
2975  Result.Kind = EK_Base;
2976  Result.Parent = Parent;
2977  Result.Base = reinterpret_cast<uintptr_t>(Base);
2978  if (IsInheritedVirtualBase)
2979  Result.Base |= 0x01;
2980 
2981  Result.Type = Base->getType();
2982  return Result;
2983 }
2984 
2986  switch (getKind()) {
2987  case EK_Parameter:
2988  case EK_Parameter_CF_Audited: {
2989  ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2990  return (D ? D->getDeclName() : DeclarationName());
2991  }
2992 
2993  case EK_Variable:
2994  case EK_Member:
2995  case EK_Binding:
2996  return Variable.VariableOrMember->getDeclName();
2997 
2998  case EK_LambdaCapture:
2999  return DeclarationName(Capture.VarID);
3000 
3001  case EK_Result:
3002  case EK_Exception:
3003  case EK_New:
3004  case EK_Temporary:
3005  case EK_Base:
3006  case EK_Delegating:
3007  case EK_ArrayElement:
3008  case EK_VectorElement:
3009  case EK_ComplexElement:
3010  case EK_BlockElement:
3011  case EK_LambdaToBlockConversionBlockElement:
3012  case EK_CompoundLiteralInit:
3013  case EK_RelatedResult:
3014  return DeclarationName();
3015  }
3016 
3017  llvm_unreachable("Invalid EntityKind!");
3018 }
3019 
3021  switch (getKind()) {
3022  case EK_Variable:
3023  case EK_Member:
3024  case EK_Binding:
3025  return Variable.VariableOrMember;
3026 
3027  case EK_Parameter:
3028  case EK_Parameter_CF_Audited:
3029  return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
3030 
3031  case EK_Result:
3032  case EK_Exception:
3033  case EK_New:
3034  case EK_Temporary:
3035  case EK_Base:
3036  case EK_Delegating:
3037  case EK_ArrayElement:
3038  case EK_VectorElement:
3039  case EK_ComplexElement:
3040  case EK_BlockElement:
3041  case EK_LambdaToBlockConversionBlockElement:
3042  case EK_LambdaCapture:
3043  case EK_CompoundLiteralInit:
3044  case EK_RelatedResult:
3045  return nullptr;
3046  }
3047 
3048  llvm_unreachable("Invalid EntityKind!");
3049 }
3050 
3052  switch (getKind()) {
3053  case EK_Result:
3054  case EK_Exception:
3055  return LocAndNRVO.NRVO;
3056 
3057  case EK_Variable:
3058  case EK_Parameter:
3059  case EK_Parameter_CF_Audited:
3060  case EK_Member:
3061  case EK_Binding:
3062  case EK_New:
3063  case EK_Temporary:
3064  case EK_CompoundLiteralInit:
3065  case EK_Base:
3066  case EK_Delegating:
3067  case EK_ArrayElement:
3068  case EK_VectorElement:
3069  case EK_ComplexElement:
3070  case EK_BlockElement:
3071  case EK_LambdaToBlockConversionBlockElement:
3072  case EK_LambdaCapture:
3073  case EK_RelatedResult:
3074  break;
3075  }
3076 
3077  return false;
3078 }
3079 
3080 unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
3081  assert(getParent() != this);
3082  unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
3083  for (unsigned I = 0; I != Depth; ++I)
3084  OS << "`-";
3085 
3086  switch (getKind()) {
3087  case EK_Variable: OS << "Variable"; break;
3088  case EK_Parameter: OS << "Parameter"; break;
3089  case EK_Parameter_CF_Audited: OS << "CF audited function Parameter";
3090  break;
3091  case EK_Result: OS << "Result"; break;
3092  case EK_Exception: OS << "Exception"; break;
3093  case EK_Member: OS << "Member"; break;
3094  case EK_Binding: OS << "Binding"; break;
3095  case EK_New: OS << "New"; break;
3096  case EK_Temporary: OS << "Temporary"; break;
3097  case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
3098  case EK_RelatedResult: OS << "RelatedResult"; break;
3099  case EK_Base: OS << "Base"; break;
3100  case EK_Delegating: OS << "Delegating"; break;
3101  case EK_ArrayElement: OS << "ArrayElement " << Index; break;
3102  case EK_VectorElement: OS << "VectorElement " << Index; break;
3103  case EK_ComplexElement: OS << "ComplexElement " << Index; break;
3104  case EK_BlockElement: OS << "Block"; break;
3105  case EK_LambdaToBlockConversionBlockElement:
3106  OS << "Block (lambda)";
3107  break;
3108  case EK_LambdaCapture:
3109  OS << "LambdaCapture ";
3110  OS << DeclarationName(Capture.VarID);
3111  break;
3112  }
3113 
3114  if (auto *D = getDecl()) {
3115  OS << " ";
3116  D->printQualifiedName(OS);
3117  }
3118 
3119  OS << " '" << getType().getAsString() << "'\n";
3120 
3121  return Depth + 1;
3122 }
3123 
3124 LLVM_DUMP_METHOD void InitializedEntity::dump() const {
3125  dumpImpl(llvm::errs());
3126 }
3127 
3128 //===----------------------------------------------------------------------===//
3129 // Initialization sequence
3130 //===----------------------------------------------------------------------===//
3131 
3133  switch (Kind) {
3134  case SK_ResolveAddressOfOverloadedFunction:
3135  case SK_CastDerivedToBaseRValue:
3136  case SK_CastDerivedToBaseXValue:
3137  case SK_CastDerivedToBaseLValue:
3138  case SK_BindReference:
3139  case SK_BindReferenceToTemporary:
3140  case SK_FinalCopy:
3141  case SK_ExtraneousCopyToTemporary:
3142  case SK_UserConversion:
3143  case SK_QualificationConversionRValue:
3144  case SK_QualificationConversionXValue:
3145  case SK_QualificationConversionLValue:
3146  case SK_AtomicConversion:
3147  case SK_LValueToRValue:
3148  case SK_ListInitialization:
3149  case SK_UnwrapInitList:
3150  case SK_RewrapInitList:
3151  case SK_ConstructorInitialization:
3152  case SK_ConstructorInitializationFromList:
3153  case SK_ZeroInitialization:
3154  case SK_CAssignment:
3155  case SK_StringInit:
3156  case SK_ObjCObjectConversion:
3157  case SK_ArrayLoopIndex:
3158  case SK_ArrayLoopInit:
3159  case SK_ArrayInit:
3160  case SK_GNUArrayInit:
3161  case SK_ParenthesizedArrayInit:
3162  case SK_PassByIndirectCopyRestore:
3163  case SK_PassByIndirectRestore:
3164  case SK_ProduceObjCObject:
3165  case SK_StdInitializerList:
3166  case SK_StdInitializerListConstructorCall:
3167  case SK_OCLSamplerInit:
3168  case SK_OCLZeroEvent:
3169  case SK_OCLZeroQueue:
3170  break;
3171 
3172  case SK_ConversionSequence:
3173  case SK_ConversionSequenceNoNarrowing:
3174  delete ICS;
3175  }
3176 }
3177 
3179  // There can be some lvalue adjustments after the SK_BindReference step.
3180  for (auto I = Steps.rbegin(); I != Steps.rend(); ++I) {
3181  if (I->Kind == SK_BindReference)
3182  return true;
3183  if (I->Kind == SK_BindReferenceToTemporary)
3184  return false;
3185  }
3186  return false;
3187 }
3188 
3190  if (!Failed())
3191  return false;
3192 
3193  switch (getFailureKind()) {
3194  case FK_TooManyInitsForReference:
3195  case FK_ParenthesizedListInitForReference:
3196  case FK_ArrayNeedsInitList:
3197  case FK_ArrayNeedsInitListOrStringLiteral:
3198  case FK_ArrayNeedsInitListOrWideStringLiteral:
3199  case FK_NarrowStringIntoWideCharArray:
3200  case FK_WideStringIntoCharArray:
3201  case FK_IncompatWideStringIntoWideChar:
3202  case FK_PlainStringIntoUTF8Char:
3203  case FK_UTF8StringIntoPlainChar:
3204  case FK_AddressOfOverloadFailed: // FIXME: Could do better
3205  case FK_NonConstLValueReferenceBindingToTemporary:
3206  case FK_NonConstLValueReferenceBindingToBitfield:
3207  case FK_NonConstLValueReferenceBindingToVectorElement:
3208  case FK_NonConstLValueReferenceBindingToUnrelated:
3209  case FK_RValueReferenceBindingToLValue:
3210  case FK_ReferenceInitDropsQualifiers:
3211  case FK_ReferenceInitFailed:
3212  case FK_ConversionFailed:
3213  case FK_ConversionFromPropertyFailed:
3214  case FK_TooManyInitsForScalar:
3215  case FK_ParenthesizedListInitForScalar:
3216  case FK_ReferenceBindingToInitList:
3217  case FK_InitListBadDestinationType:
3218  case FK_DefaultInitOfConst:
3219  case FK_Incomplete:
3220  case FK_ArrayTypeMismatch:
3221  case FK_NonConstantArrayInit:
3222  case FK_ListInitializationFailed:
3223  case FK_VariableLengthArrayHasInitializer:
3224  case FK_PlaceholderType:
3225  case FK_ExplicitConstructor:
3226  case FK_AddressOfUnaddressableFunction:
3227  return false;
3228 
3229  case FK_ReferenceInitOverloadFailed:
3230  case FK_UserConversionOverloadFailed:
3231  case FK_ConstructorOverloadFailed:
3232  case FK_ListConstructorOverloadFailed:
3233  return FailedOverloadResult == OR_Ambiguous;
3234  }
3235 
3236  llvm_unreachable("Invalid EntityKind!");
3237 }
3238 
3240  return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
3241 }
3242 
3243 void
3246  DeclAccessPair Found,
3247  bool HadMultipleCandidates) {
3248  Step S;
3249  S.Kind = SK_ResolveAddressOfOverloadedFunction;
3250  S.Type = Function->getType();
3251  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3252  S.Function.Function = Function;
3253  S.Function.FoundDecl = Found;
3254  Steps.push_back(S);
3255 }
3256 
3258  ExprValueKind VK) {
3259  Step S;
3260  switch (VK) {
3261  case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
3262  case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
3263  case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
3264  }
3265  S.Type = BaseType;
3266  Steps.push_back(S);
3267 }
3268 
3270  bool BindingTemporary) {
3271  Step S;
3272  S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
3273  S.Type = T;
3274  Steps.push_back(S);
3275 }
3276 
3278  Step S;
3279  S.Kind = SK_FinalCopy;
3280  S.Type = T;
3281  Steps.push_back(S);
3282 }
3283 
3285  Step S;
3286  S.Kind = SK_ExtraneousCopyToTemporary;
3287  S.Type = T;
3288  Steps.push_back(S);
3289 }
3290 
3291 void
3293  DeclAccessPair FoundDecl,
3294  QualType T,
3295  bool HadMultipleCandidates) {
3296  Step S;
3297  S.Kind = SK_UserConversion;
3298  S.Type = T;
3299  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3300  S.Function.Function = Function;
3301  S.Function.FoundDecl = FoundDecl;
3302  Steps.push_back(S);
3303 }
3304 
3306  ExprValueKind VK) {
3307  Step S;
3308  S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
3309  switch (VK) {
3310  case VK_RValue:
3311  S.Kind = SK_QualificationConversionRValue;
3312  break;
3313  case VK_XValue:
3314  S.Kind = SK_QualificationConversionXValue;
3315  break;
3316  case VK_LValue:
3317  S.Kind = SK_QualificationConversionLValue;
3318  break;
3319  }
3320  S.Type = Ty;
3321  Steps.push_back(S);
3322 }
3323 
3325  Step S;
3326  S.Kind = SK_AtomicConversion;
3327  S.Type = Ty;
3328  Steps.push_back(S);
3329 }
3330 
3332  assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
3333 
3334  Step S;
3335  S.Kind = SK_LValueToRValue;
3336  S.Type = Ty;
3337  Steps.push_back(S);
3338 }
3339 
3341  const ImplicitConversionSequence &ICS, QualType T,
3342  bool TopLevelOfInitList) {
3343  Step S;
3344  S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing
3345  : SK_ConversionSequence;
3346  S.Type = T;
3347  S.ICS = new ImplicitConversionSequence(ICS);
3348  Steps.push_back(S);
3349 }
3350 
3352  Step S;
3353  S.Kind = SK_ListInitialization;
3354  S.Type = T;
3355  Steps.push_back(S);
3356 }
3357 
3359  DeclAccessPair FoundDecl, CXXConstructorDecl *Constructor, QualType T,
3360  bool HadMultipleCandidates, bool FromInitList, bool AsInitList) {
3361  Step S;
3362  S.Kind = FromInitList ? AsInitList ? SK_StdInitializerListConstructorCall
3363  : SK_ConstructorInitializationFromList
3364  : SK_ConstructorInitialization;
3365  S.Type = T;
3366  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3367  S.Function.Function = Constructor;
3368  S.Function.FoundDecl = FoundDecl;
3369  Steps.push_back(S);
3370 }
3371 
3373  Step S;
3374  S.Kind = SK_ZeroInitialization;
3375  S.Type = T;
3376  Steps.push_back(S);
3377 }
3378 
3380  Step S;
3381  S.Kind = SK_CAssignment;
3382  S.Type = T;
3383  Steps.push_back(S);
3384 }
3385 
3387  Step S;
3388  S.Kind = SK_StringInit;
3389  S.Type = T;
3390  Steps.push_back(S);
3391 }
3392 
3394  Step S;
3395  S.Kind = SK_ObjCObjectConversion;
3396  S.Type = T;
3397  Steps.push_back(S);
3398 }
3399 
3401  Step S;
3402  S.Kind = IsGNUExtension ? SK_GNUArrayInit : SK_ArrayInit;
3403  S.Type = T;
3404  Steps.push_back(S);
3405 }
3406 
3408  Step S;
3409  S.Kind = SK_ArrayLoopIndex;
3410  S.Type = EltT;
3411  Steps.insert(Steps.begin(), S);
3412 
3413  S.Kind = SK_ArrayLoopInit;
3414  S.Type = T;
3415  Steps.push_back(S);
3416 }
3417 
3419  Step S;
3420  S.Kind = SK_ParenthesizedArrayInit;
3421  S.Type = T;
3422  Steps.push_back(S);
3423 }
3424 
3426  bool shouldCopy) {
3427  Step s;
3428  s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
3429  : SK_PassByIndirectRestore);
3430  s.Type = type;
3431  Steps.push_back(s);
3432 }
3433 
3435  Step S;
3436  S.Kind = SK_ProduceObjCObject;
3437  S.Type = T;
3438  Steps.push_back(S);
3439 }
3440 
3442  Step S;
3443  S.Kind = SK_StdInitializerList;
3444  S.Type = T;
3445  Steps.push_back(S);
3446 }
3447 
3449  Step S;
3450  S.Kind = SK_OCLSamplerInit;
3451  S.Type = T;
3452  Steps.push_back(S);
3453 }
3454 
3456  Step S;
3457  S.Kind = SK_OCLZeroEvent;
3458  S.Type = T;
3459  Steps.push_back(S);
3460 }
3461 
3463  Step S;
3464  S.Kind = SK_OCLZeroQueue;
3465  S.Type = T;
3466  Steps.push_back(S);
3467 }
3468 
3470  InitListExpr *Syntactic) {
3471  assert(Syntactic->getNumInits() == 1 &&
3472  "Can only rewrap trivial init lists.");
3473  Step S;
3474  S.Kind = SK_UnwrapInitList;
3475  S.Type = Syntactic->getInit(0)->getType();
3476  Steps.insert(Steps.begin(), S);
3477 
3478  S.Kind = SK_RewrapInitList;
3479  S.Type = T;
3480  S.WrappingSyntacticList = Syntactic;
3481  Steps.push_back(S);
3482 }
3483 
3486  setSequenceKind(FailedSequence);
3487  this->Failure = Failure;
3488  this->FailedOverloadResult = Result;
3489 }
3490 
3491 //===----------------------------------------------------------------------===//
3492 // Attempt initialization
3493 //===----------------------------------------------------------------------===//
3494 
3495 /// Tries to add a zero initializer. Returns true if that worked.
3496 static bool
3498  const InitializedEntity &Entity) {
3499  if (Entity.getKind() != InitializedEntity::EK_Variable)
3500  return false;
3501 
3502  VarDecl *VD = cast<VarDecl>(Entity.getDecl());
3503  if (VD->getInit() || VD->getLocEnd().isMacroID())
3504  return false;
3505 
3506  QualType VariableTy = VD->getType().getCanonicalType();
3508  std::string Init = S.getFixItZeroInitializerForType(VariableTy, Loc);
3509  if (!Init.empty()) {
3510  Sequence.AddZeroInitializationStep(Entity.getType());
3511  Sequence.SetZeroInitializationFixit(Init, Loc);
3512  return true;
3513  }
3514  return false;
3515 }
3516 
3518  InitializationSequence &Sequence,
3519  const InitializedEntity &Entity) {
3520  if (!S.getLangOpts().ObjCAutoRefCount) return;
3521 
3522  /// When initializing a parameter, produce the value if it's marked
3523  /// __attribute__((ns_consumed)).
3524  if (Entity.isParameterKind()) {
3525  if (!Entity.isParameterConsumed())
3526  return;
3527 
3528  assert(Entity.getType()->isObjCRetainableType() &&
3529  "consuming an object of unretainable type?");
3530  Sequence.AddProduceObjCObjectStep(Entity.getType());
3531 
3532  /// When initializing a return value, if the return type is a
3533  /// retainable type, then returns need to immediately retain the
3534  /// object. If an autorelease is required, it will be done at the
3535  /// last instant.
3536  } else if (Entity.getKind() == InitializedEntity::EK_Result) {
3537  if (!Entity.getType()->isObjCRetainableType())
3538  return;
3539 
3540  Sequence.AddProduceObjCObjectStep(Entity.getType());
3541  }
3542 }
3543 
3544 static void TryListInitialization(Sema &S,
3545  const InitializedEntity &Entity,
3546  const InitializationKind &Kind,
3547  InitListExpr *InitList,
3548  InitializationSequence &Sequence,
3549  bool TreatUnavailableAsInvalid);
3550 
3551 /// When initializing from init list via constructor, handle
3552 /// initialization of an object of type std::initializer_list<T>.
3553 ///
3554 /// \return true if we have handled initialization of an object of type
3555 /// std::initializer_list<T>, false otherwise.
3557  InitListExpr *List,
3558  QualType DestType,
3559  InitializationSequence &Sequence,
3560  bool TreatUnavailableAsInvalid) {
3561  QualType E;
3562  if (!S.isStdInitializerList(DestType, &E))
3563  return false;
3564 
3565  if (!S.isCompleteType(List->getExprLoc(), E)) {
3566  Sequence.setIncompleteTypeFailure(E);
3567  return true;
3568  }
3569 
3570  // Try initializing a temporary array from the init list.
3572  E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
3573  List->getNumInits()),
3575  InitializedEntity HiddenArray =
3578  List->getExprLoc(), List->getLocStart(), List->getLocEnd());
3579  TryListInitialization(S, HiddenArray, Kind, List, Sequence,
3580  TreatUnavailableAsInvalid);
3581  if (Sequence)
3582  Sequence.AddStdInitializerListConstructionStep(DestType);
3583  return true;
3584 }
3585 
3586 /// Determine if the constructor has the signature of a copy or move
3587 /// constructor for the type T of the class in which it was found. That is,
3588 /// determine if its first parameter is of type T or reference to (possibly
3589 /// cv-qualified) T.
3591  const ConstructorInfo &Info) {
3592  if (Info.Constructor->getNumParams() == 0)
3593  return false;
3594 
3595  QualType ParmT =
3597  QualType ClassT =
3598  Ctx.getRecordType(cast<CXXRecordDecl>(Info.FoundDecl->getDeclContext()));
3599 
3600  return Ctx.hasSameUnqualifiedType(ParmT, ClassT);
3601 }
3602 
3603 static OverloadingResult
3605  MultiExprArg Args,
3606  OverloadCandidateSet &CandidateSet,
3607  QualType DestType,
3610  bool CopyInitializing, bool AllowExplicit,
3611  bool OnlyListConstructors, bool IsListInit,
3612  bool SecondStepOfCopyInit = false) {
3614 
3615  for (NamedDecl *D : Ctors) {
3616  auto Info = getConstructorInfo(D);
3617  if (!Info.Constructor || Info.Constructor->isInvalidDecl())
3618  continue;
3619 
3620  if (!AllowExplicit && Info.Constructor->isExplicit())
3621  continue;
3622 
3623  if (OnlyListConstructors && !S.isInitListConstructor(Info.Constructor))
3624  continue;
3625 
3626  // C++11 [over.best.ics]p4:
3627  // ... and the constructor or user-defined conversion function is a
3628  // candidate by
3629  // - 13.3.1.3, when the argument is the temporary in the second step
3630  // of a class copy-initialization, or
3631  // - 13.3.1.4, 13.3.1.5, or 13.3.1.6 (in all cases), [not handled here]
3632  // - the second phase of 13.3.1.7 when the initializer list has exactly
3633  // one element that is itself an initializer list, and the target is
3634  // the first parameter of a constructor of class X, and the conversion
3635  // is to X or reference to (possibly cv-qualified X),
3636  // user-defined conversion sequences are not considered.
3637  bool SuppressUserConversions =
3638  SecondStepOfCopyInit ||
3639  (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
3640  hasCopyOrMoveCtorParam(S.Context, Info));
3641 
3642  if (Info.ConstructorTmpl)
3643  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
3644  /*ExplicitArgs*/ nullptr, Args,
3645  CandidateSet, SuppressUserConversions);
3646  else {
3647  // C++ [over.match.copy]p1:
3648  // - When initializing a temporary to be bound to the first parameter
3649  // of a constructor [for type T] that takes a reference to possibly
3650  // cv-qualified T as its first argument, called with a single
3651  // argument in the context of direct-initialization, explicit
3652  // conversion functions are also considered.
3653  // FIXME: What if a constructor template instantiates to such a signature?
3654  bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
3655  Args.size() == 1 &&
3657  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, Args,
3658  CandidateSet, SuppressUserConversions,
3659  /*PartialOverloading=*/false,
3660  /*AllowExplicit=*/AllowExplicitConv);
3661  }
3662  }
3663 
3664  // FIXME: Work around a bug in C++17 guaranteed copy elision.
3665  //
3666  // When initializing an object of class type T by constructor
3667  // ([over.match.ctor]) or by list-initialization ([over.match.list])
3668  // from a single expression of class type U, conversion functions of
3669  // U that convert to the non-reference type cv T are candidates.
3670  // Explicit conversion functions are only candidates during
3671  // direct-initialization.
3672  //
3673  // Note: SecondStepOfCopyInit is only ever true in this case when
3674  // evaluating whether to produce a C++98 compatibility warning.
3675  if (S.getLangOpts().CPlusPlus17 && Args.size() == 1 &&
3676  !SecondStepOfCopyInit) {
3677  Expr *Initializer = Args[0];
3678  auto *SourceRD = Initializer->getType()->getAsCXXRecordDecl();
3679  if (SourceRD && S.isCompleteType(DeclLoc, Initializer->getType())) {
3680  const auto &Conversions = SourceRD->getVisibleConversionFunctions();
3681  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3682  NamedDecl *D = *I;
3683  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3684  D = D->getUnderlyingDecl();
3685 
3686  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
3687  CXXConversionDecl *Conv;
3688  if (ConvTemplate)
3689  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3690  else
3691  Conv = cast<CXXConversionDecl>(D);
3692 
3693  if ((AllowExplicit && !CopyInitializing) || !Conv->isExplicit()) {
3694  if (ConvTemplate)
3695  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
3696  ActingDC, Initializer, DestType,
3697  CandidateSet, AllowExplicit,
3698  /*AllowResultConversion*/false);
3699  else
3700  S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Initializer,
3701  DestType, CandidateSet, AllowExplicit,
3702  /*AllowResultConversion*/false);
3703  }
3704  }
3705  }
3706  }
3707 
3708  // Perform overload resolution and return the result.
3709  return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3710 }
3711 
3712 /// Attempt initialization by constructor (C++ [dcl.init]), which
3713 /// enumerates the constructors of the initialized entity and performs overload
3714 /// resolution to select the best.
3715 /// \param DestType The destination class type.
3716 /// \param DestArrayType The destination type, which is either DestType or
3717 /// a (possibly multidimensional) array of DestType.
3718 /// \param IsListInit Is this list-initialization?
3719 /// \param IsInitListCopy Is this non-list-initialization resulting from a
3720 /// list-initialization from {x} where x is the same
3721 /// type as the entity?
3723  const InitializedEntity &Entity,
3724  const InitializationKind &Kind,
3725  MultiExprArg Args, QualType DestType,
3726  QualType DestArrayType,
3727  InitializationSequence &Sequence,
3728  bool IsListInit = false,
3729  bool IsInitListCopy = false) {
3730  assert(((!IsListInit && !IsInitListCopy) ||
3731  (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
3732  "IsListInit/IsInitListCopy must come with a single initializer list "
3733  "argument.");
3734  InitListExpr *ILE =
3735  (IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) : nullptr;
3736  MultiExprArg UnwrappedArgs =
3737  ILE ? MultiExprArg(ILE->getInits(), ILE->getNumInits()) : Args;
3738 
3739  // The type we're constructing needs to be complete.
3740  if (!S.isCompleteType(Kind.getLocation(), DestType)) {
3741  Sequence.setIncompleteTypeFailure(DestType);
3742  return;
3743  }
3744 
3745  // C++17 [dcl.init]p17:
3746  // - If the initializer expression is a prvalue and the cv-unqualified
3747  // version of the source type is the same class as the class of the
3748  // destination, the initializer expression is used to initialize the
3749  // destination object.
3750  // Per DR (no number yet), this does not apply when initializing a base
3751  // class or delegating to another constructor from a mem-initializer.
3752  // ObjC++: Lambda captured by the block in the lambda to block conversion
3753  // should avoid copy elision.
3754  if (S.getLangOpts().CPlusPlus17 &&
3755  Entity.getKind() != InitializedEntity::EK_Base &&
3757  Entity.getKind() !=
3759  UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isRValue() &&
3760  S.Context.hasSameUnqualifiedType(UnwrappedArgs[0]->getType(), DestType)) {
3761  // Convert qualifications if necessary.
3762  Sequence.AddQualificationConversionStep(DestType, VK_RValue);
3763  if (ILE)
3764  Sequence.RewrapReferenceInitList(DestType, ILE);
3765  return;
3766  }
3767 
3768  const RecordType *DestRecordType = DestType->getAs<RecordType>();
3769  assert(DestRecordType && "Constructor initialization requires record type");
3770  CXXRecordDecl *DestRecordDecl
3771  = cast<CXXRecordDecl>(DestRecordType->getDecl());
3772 
3773  // Build the candidate set directly in the initialization sequence
3774  // structure, so that it will persist if we fail.
3775  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3776 
3777  // Determine whether we are allowed to call explicit constructors or
3778  // explicit conversion operators.
3779  bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
3780  bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
3781 
3782  // - Otherwise, if T is a class type, constructors are considered. The
3783  // applicable constructors are enumerated, and the best one is chosen
3784  // through overload resolution.
3785  DeclContext::lookup_result Ctors = S.LookupConstructors(DestRecordDecl);
3786 
3789  bool AsInitializerList = false;
3790 
3791  // C++11 [over.match.list]p1, per DR1467:
3792  // When objects of non-aggregate type T are list-initialized, such that
3793  // 8.5.4 [dcl.init.list] specifies that overload resolution is performed
3794  // according to the rules in this section, overload resolution selects
3795  // the constructor in two phases:
3796  //
3797  // - Initially, the candidate functions are the initializer-list
3798  // constructors of the class T and the argument list consists of the
3799  // initializer list as a single argument.
3800  if (IsListInit) {
3801  AsInitializerList = true;
3802 
3803  // If the initializer list has no elements and T has a default constructor,
3804  // the first phase is omitted.
3805  if (!(UnwrappedArgs.empty() && DestRecordDecl->hasDefaultConstructor()))
3806  Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3807  CandidateSet, DestType, Ctors, Best,
3808  CopyInitialization, AllowExplicit,
3809  /*OnlyListConstructor=*/true,
3810  IsListInit);
3811  }
3812 
3813  // C++11 [over.match.list]p1:
3814  // - If no viable initializer-list constructor is found, overload resolution
3815  // is performed again, where the candidate functions are all the
3816  // constructors of the class T and the argument list consists of the
3817  // elements of the initializer list.
3818  if (Result == OR_No_Viable_Function) {
3819  AsInitializerList = false;
3820  Result = ResolveConstructorOverload(S, Kind.getLocation(), UnwrappedArgs,
3821  CandidateSet, DestType, Ctors, Best,
3822  CopyInitialization, AllowExplicit,
3823  /*OnlyListConstructors=*/false,
3824  IsListInit);
3825  }
3826  if (Result) {
3827  Sequence.SetOverloadFailure(IsListInit ?
3830  Result);
3831  return;
3832  }
3833 
3834  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3835 
3836  // In C++17, ResolveConstructorOverload can select a conversion function
3837  // instead of a constructor.
3838  if (auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
3839  // Add the user-defined conversion step that calls the conversion function.
3840  QualType ConvType = CD->getConversionType();
3841  assert(S.Context.hasSameUnqualifiedType(ConvType, DestType) &&
3842  "should not have selected this conversion function");
3843  Sequence.AddUserConversionStep(CD, Best->FoundDecl, ConvType,
3844  HadMultipleCandidates);
3845  if (!S.Context.hasSameType(ConvType, DestType))
3846  Sequence.AddQualificationConversionStep(DestType, VK_RValue);
3847  if (IsListInit)
3848  Sequence.RewrapReferenceInitList(Entity.getType(), ILE);
3849  return;
3850  }
3851 
3852  // C++11 [dcl.init]p6:
3853  // If a program calls for the default initialization of an object
3854  // of a const-qualified type T, T shall be a class type with a
3855  // user-provided default constructor.
3856  // C++ core issue 253 proposal:
3857  // If the implicit default constructor initializes all subobjects, no
3858  // initializer should be required.
3859  // The 253 proposal is for example needed to process libstdc++ headers in 5.x.
3860  CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3861  if (Kind.getKind() == InitializationKind::IK_Default &&
3862  Entity.getType().isConstQualified()) {
3863  if (!CtorDecl->getParent()->allowConstDefaultInit()) {
3864  if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
3866  return;
3867  }
3868  }
3869 
3870  // C++11 [over.match.list]p1:
3871  // In copy-list-initialization, if an explicit constructor is chosen, the
3872  // initializer is ill-formed.
3873  if (IsListInit && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3875  return;
3876  }
3877 
3878  // Add the constructor initialization step. Any cv-qualification conversion is
3879  // subsumed by the initialization.
3881  Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,
3882  IsListInit | IsInitListCopy, AsInitializerList);
3883 }
3884 
3885 static bool
3887  Expr *Initializer,
3888  QualType &SourceType,
3889  QualType &UnqualifiedSourceType,
3890  QualType UnqualifiedTargetType,
3891  InitializationSequence &Sequence) {
3892  if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
3893  S.Context.OverloadTy) {
3894  DeclAccessPair Found;
3895  bool HadMultipleCandidates = false;
3896  if (FunctionDecl *Fn
3897  = S.ResolveAddressOfOverloadedFunction(Initializer,
3898  UnqualifiedTargetType,
3899  false, Found,
3900  &HadMultipleCandidates)) {
3901  Sequence.AddAddressOverloadResolutionStep(Fn, Found,
3902  HadMultipleCandidates);
3903  SourceType = Fn->getType();
3904  UnqualifiedSourceType = SourceType.getUnqualifiedType();
3905  } else if (!UnqualifiedTargetType->isRecordType()) {
3907  return true;
3908  }
3909  }
3910  return false;
3911 }
3912 
3913 static void TryReferenceInitializationCore(Sema &S,
3914  const InitializedEntity &Entity,
3915  const InitializationKind &Kind,
3916  Expr *Initializer,
3917  QualType cv1T1, QualType T1,
3918  Qualifiers T1Quals,
3919  QualType cv2T2, QualType T2,
3920  Qualifiers T2Quals,
3921  InitializationSequence &Sequence);
3922 
3923 static void TryValueInitialization(Sema &S,
3924  const InitializedEntity &Entity,
3925  const InitializationKind &Kind,
3926  InitializationSequence &Sequence,
3927  InitListExpr *InitList = nullptr);
3928 
3929 /// Attempt list initialization of a reference.
3931  const InitializedEntity &Entity,
3932  const InitializationKind &Kind,
3933  InitListExpr *InitList,
3934  InitializationSequence &Sequence,
3935  bool TreatUnavailableAsInvalid) {
3936  // First, catch C++03 where this isn't possible.
3937  if (!S.getLangOpts().CPlusPlus11) {
3939  return;
3940  }
3941  // Can't reference initialize a compound literal.
3944  return;
3945  }
3946 
3947  QualType DestType = Entity.getType();
3948  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3949  Qualifiers T1Quals;
3950  QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3951 
3952  // Reference initialization via an initializer list works thus:
3953  // If the initializer list consists of a single element that is
3954  // reference-related to the referenced type, bind directly to that element
3955  // (possibly creating temporaries).
3956  // Otherwise, initialize a temporary with the initializer list and
3957  // bind to that.
3958  if (InitList->getNumInits() == 1) {
3959  Expr *Initializer = InitList->getInit(0);
3960  QualType cv2T2 = Initializer->getType();
3961  Qualifiers T2Quals;
3962  QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3963 
3964  // If this fails, creating a temporary wouldn't work either.
3965  if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3966  T1, Sequence))
3967  return;
3968 
3969  SourceLocation DeclLoc = Initializer->getLocStart();
3970  bool dummy1, dummy2, dummy3;
3971  Sema::ReferenceCompareResult RefRelationship
3972  = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3973  dummy2, dummy3);
3974  if (RefRelationship >= Sema::Ref_Related) {
3975  // Try to bind the reference here.
3976  TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3977  T1Quals, cv2T2, T2, T2Quals, Sequence);
3978  if (Sequence)
3979  Sequence.RewrapReferenceInitList(cv1T1, InitList);
3980  return;
3981  }
3982 
3983  // Update the initializer if we've resolved an overloaded function.
3984  if (Sequence.step_begin() != Sequence.step_end())
3985  Sequence.RewrapReferenceInitList(cv1T1, InitList);
3986  }
3987 
3988  // Not reference-related. Create a temporary and bind to that.
3990 
3991  TryListInitialization(S, TempEntity, Kind, InitList, Sequence,
3992  TreatUnavailableAsInvalid);
3993  if (Sequence) {
3994  if (DestType->isRValueReferenceType() ||
3995  (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3996  Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3997  else
3998  Sequence.SetFailed(
4000  }
4001 }
4002 
4003 /// Attempt list initialization (C++0x [dcl.init.list])
4005  const InitializedEntity &Entity,
4006  const InitializationKind &Kind,
4007  InitListExpr *InitList,
4008  InitializationSequence &Sequence,
4009  bool TreatUnavailableAsInvalid) {
4010  QualType DestType = Entity.getType();
4011 
4012  // C++ doesn't allow scalar initialization with more than one argument.
4013  // But C99 complex numbers are scalars and it makes sense there.
4014  if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
4015  !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
4017  return;
4018  }
4019  if (DestType->isReferenceType()) {
4020  TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence,
4021  TreatUnavailableAsInvalid);
4022  return;
4023  }
4024 
4025  if (DestType->isRecordType() &&
4026  !S.isCompleteType(InitList->getLocStart(), DestType)) {
4027  Sequence.setIncompleteTypeFailure(DestType);
4028  return;
4029  }
4030 
4031  // C++11 [dcl.init.list]p3, per DR1467:
4032  // - If T is a class type and the initializer list has a single element of
4033  // type cv U, where U is T or a class derived from T, the object is
4034  // initialized from that element (by copy-initialization for
4035  // copy-list-initialization, or by direct-initialization for
4036  // direct-list-initialization).
4037  // - Otherwise, if T is a character array and the initializer list has a
4038  // single element that is an appropriately-typed string literal
4039  // (8.5.2 [dcl.init.string]), initialization is performed as described
4040  // in that section.
4041  // - Otherwise, if T is an aggregate, [...] (continue below).
4042  if (S.getLangOpts().CPlusPlus11 && InitList->getNumInits() == 1) {
4043  if (DestType->isRecordType()) {
4044  QualType InitType = InitList->getInit(0)->getType();
4045  if (S.Context.hasSameUnqualifiedType(InitType, DestType) ||
4046  S.IsDerivedFrom(InitList->getLocStart(), InitType, DestType)) {
4047  Expr *InitListAsExpr = InitList;
4048  TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
4049  DestType, Sequence,
4050  /*InitListSyntax*/false,
4051  /*IsInitListCopy*/true);
4052  return;
4053  }
4054  }
4055  if (const ArrayType *DestAT = S.Context.getAsArrayType(DestType)) {
4056  Expr *SubInit[1] = {InitList->getInit(0)};
4057  if (!isa<VariableArrayType>(DestAT) &&
4058  IsStringInit(SubInit[0], DestAT, S.Context) == SIF_None) {
4059  InitializationKind SubKind =
4062  InitList->getLBraceLoc(),
4063  InitList->getRBraceLoc())
4064  : Kind;
4065  Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
4066  /*TopLevelOfInitList*/ true,
4067  TreatUnavailableAsInvalid);
4068 
4069  // TryStringLiteralInitialization() (in InitializeFrom()) will fail if
4070  // the element is not an appropriately-typed string literal, in which
4071  // case we should proceed as in C++11 (below).
4072  if (Sequence) {
4073  Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
4074  return;
4075  }
4076  }
4077  }
4078  }
4079 
4080  // C++11 [dcl.init.list]p3:
4081  // - If T is an aggregate, aggregate initialization is performed.
4082  if ((DestType->isRecordType() && !DestType->isAggregateType()) ||
4083  (S.getLangOpts().CPlusPlus11 &&
4084  S.isStdInitializerList(DestType, nullptr))) {
4085  if (S.getLangOpts().CPlusPlus11) {
4086  // - Otherwise, if the initializer list has no elements and T is a
4087  // class type with a default constructor, the object is
4088  // value-initialized.
4089  if (InitList->getNumInits() == 0) {
4090  CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
4091  if (RD->hasDefaultConstructor()) {
4092  TryValueInitialization(S, Entity, Kind, Sequence, InitList);
4093  return;
4094  }
4095  }
4096 
4097  // - Otherwise, if T is a specialization of std::initializer_list<E>,
4098  // an initializer_list object constructed [...]
4099  if (TryInitializerListConstruction(S, InitList, DestType, Sequence,
4100  TreatUnavailableAsInvalid))
4101  return;
4102 
4103  // - Otherwise, if T is a class type, constructors are considered.
4104  Expr *InitListAsExpr = InitList;
4105  TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
4106  DestType, Sequence, /*InitListSyntax*/true);
4107  } else
4109  return;
4110  }
4111 
4112  if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() &&
4113  InitList->getNumInits() == 1) {
4114  Expr *E = InitList->getInit(0);
4115 
4116  // - Otherwise, if T is an enumeration with a fixed underlying type,
4117  // the initializer-list has a single element v, and the initialization
4118  // is direct-list-initialization, the object is initialized with the
4119  // value T(v); if a narrowing conversion is required to convert v to
4120  // the underlying type of T, the program is ill-formed.
4121  auto *ET = DestType->getAs<EnumType>();
4122  if (S.getLangOpts().CPlusPlus17 &&
4124  ET && ET->getDecl()->isFixed() &&
4125  !S.Context.hasSameUnqualifiedType(E->getType(), DestType) &&
4127  E->getType()->isFloatingType())) {
4128  // There are two ways that T(v) can work when T is an enumeration type.
4129  // If there is either an implicit conversion sequence from v to T or
4130  // a conversion function that can convert from v to T, then we use that.
4131  // Otherwise, if v is of integral, enumeration, or floating-point type,
4132  // it is converted to the enumeration type via its underlying type.
4133  // There is no overlap possible between these two cases (except when the
4134  // source value is already of the destination type), and the first
4135  // case is handled by the general case for single-element lists below.
4137  ICS.setStandard();
4139  if (!E->isRValue())
4141  // If E is of a floating-point type, then the conversion is ill-formed
4142  // due to narrowing, but go through the motions in order to produce the
4143  // right diagnostic.
4144  ICS.Standard.Second = E->getType()->isFloatingType()
4147  ICS.Standard.setFromType(E->getType());
4148  ICS.Standard.setToType(0, E->getType());
4149  ICS.Standard.setToType(1, DestType);
4150  ICS.Standard.setToType(2, DestType);
4151  Sequence.AddConversionSequenceStep(ICS, ICS.Standard.getToType(2),
4152  /*TopLevelOfInitList*/true);
4153  Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
4154  return;
4155  }
4156 
4157  // - Otherwise, if the initializer list has a single element of type E
4158  // [...references are handled above...], the object or reference is
4159  // initialized from that element (by copy-initialization for
4160  // copy-list-initialization, or by direct-initialization for
4161  // direct-list-initialization); if a narrowing conversion is required
4162  // to convert the element to T, the program is ill-formed.
4163  //
4164  // Per core-24034, this is direct-initialization if we were performing
4165  // direct-list-initialization and copy-initialization otherwise.
4166  // We can't use InitListChecker for this, because it always performs
4167  // copy-initialization. This only matters if we might use an 'explicit'
4168  // conversion operator, so we only need to handle the cases where the source
4169  // is of record type.
4170  if (InitList->getInit(0)->getType()->isRecordType()) {
4171  InitializationKind SubKind =
4174  InitList->getLBraceLoc(),
4175  InitList->getRBraceLoc())
4176  : Kind;
4177  Expr *SubInit[1] = { InitList->getInit(0) };
4178  Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
4179  /*TopLevelOfInitList*/true,
4180  TreatUnavailableAsInvalid);
4181  if (Sequence)
4182  Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
4183  return;
4184  }
4185  }
4186 
4187  InitListChecker CheckInitList(S, Entity, InitList,
4188  DestType, /*VerifyOnly=*/true, TreatUnavailableAsInvalid);
4189  if (CheckInitList.HadError()) {
4191  return;
4192  }
4193 
4194  // Add the list initialization step with the built init list.
4195  Sequence.AddListInitializationStep(DestType);
4196 }
4197 
4198 /// Try a reference initialization that involves calling a conversion
4199 /// function.
4201  Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind,
4202  Expr *Initializer, bool AllowRValues, bool IsLValueRef,
4203  InitializationSequence &Sequence) {
4204  QualType DestType = Entity.getType();
4205  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
4206  QualType T1 = cv1T1.getUnqualifiedType();
4207  QualType cv2T2 = Initializer->getType();
4208  QualType T2 = cv2T2.getUnqualifiedType();
4209 
4210  bool DerivedToBase;
4211  bool ObjCConversion;
4212  bool ObjCLifetimeConversion;
4213  assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
4214  T1, T2, DerivedToBase,
4215  ObjCConversion,
4216  ObjCLifetimeConversion) &&
4217  "Must have incompatible references when binding via conversion");
4218  (void)DerivedToBase;
4219  (void)ObjCConversion;
4220  (void)ObjCLifetimeConversion;
4221 
4222  // Build the candidate set directly in the initialization sequence
4223  // structure, so that it will persist if we fail.
4224  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4226 
4227  // Determine whether we are allowed to call explicit constructors or
4228  // explicit conversion operators.
4229  bool AllowExplicit = Kind.AllowExplicit();
4230  bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
4231 
4232  const RecordType *T1RecordType = nullptr;
4233  if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
4234  S.isCompleteType(Kind.getLocation(), T1)) {
4235  // The type we're converting to is a class type. Enumerate its constructors
4236  // to see if there is a suitable conversion.
4237  CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
4238 
4239  for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) {
4240  auto Info = getConstructorInfo(D);
4241  if (!Info.Constructor)
4242  continue;
4243 
4244  if (!Info.Constructor->isInvalidDecl() &&
4245  Info.Constructor->isConvertingConstructor(AllowExplicit)) {
4246  if (Info.ConstructorTmpl)
4247  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
4248  /*ExplicitArgs*/ nullptr,
4249  Initializer, CandidateSet,
4250  /*SuppressUserConversions=*/true);
4251  else
4252  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
4253  Initializer, CandidateSet,
4254  /*SuppressUserConversions=*/true);
4255  }
4256  }
4257  }
4258  if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
4259  return OR_No_Viable_Function;
4260 
4261  const RecordType *T2RecordType = nullptr;
4262  if ((T2RecordType = T2->getAs<RecordType>()) &&
4263  S.isCompleteType(Kind.getLocation(), T2)) {
4264  // The type we're converting from is a class type, enumerate its conversion
4265  // functions.
4266  CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
4267 
4268  const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4269  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4270  NamedDecl *D = *I;
4271  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4272  if (isa<UsingShadowDecl>(D))
4273  D = cast<UsingShadowDecl>(D)->getTargetDecl();
4274 
4275  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4276  CXXConversionDecl *Conv;
4277  if (ConvTemplate)
4278  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4279  else
4280  Conv = cast<CXXConversionDecl>(D);
4281 
4282  // If the conversion function doesn't return a reference type,
4283  // it can't be considered for this conversion unless we're allowed to
4284  // consider rvalues.
4285  // FIXME: Do we need to make sure that we only consider conversion
4286  // candidates with reference-compatible results? That might be needed to
4287  // break recursion.
4288  if ((AllowExplicitConvs || !Conv->isExplicit()) &&
4289  (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
4290  if (ConvTemplate)
4291  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4292  ActingDC, Initializer,
4293  DestType, CandidateSet,
4294  /*AllowObjCConversionOnExplicit=*/
4295  false);
4296  else
4297  S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4298  Initializer, DestType, CandidateSet,
4299  /*AllowObjCConversionOnExplicit=*/false);
4300  }
4301  }
4302  }
4303  if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
4304  return OR_No_Viable_Function;
4305 
4306  SourceLocation DeclLoc = Initializer->getLocStart();
4307 
4308  // Perform overload resolution. If it fails, return the failed result.
4311  = CandidateSet.BestViableFunction(S, DeclLoc, Best))
4312  return Result;
4313 
4314  FunctionDecl *Function = Best->Function;
4315  // This is the overload that will be used for this initialization step if we
4316  // use this initialization. Mark it as referenced.
4317  Function->setReferenced();
4318 
4319  // Compute the returned type and value kind of the conversion.
4320  QualType cv3T3;
4321  if (isa<CXXConversionDecl>(Function))
4322  cv3T3 = Function->getReturnType();
4323  else
4324  cv3T3 = T1;
4325 
4326  ExprValueKind VK = VK_RValue;
4327  if (cv3T3->isLValueReferenceType())
4328  VK = VK_LValue;
4329  else if (const auto *RRef = cv3T3->getAs<RValueReferenceType>())
4330  VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
4331  cv3T3 = cv3T3.getNonLValueExprType(S.Context);
4332 
4333  // Add the user-defined conversion step.
4334  bool HadMultipleCandidates = (CandidateSet.size() > 1);
4335  Sequence.AddUserConversionStep(Function, Best->FoundDecl, cv3T3,
4336  HadMultipleCandidates);
4337 
4338  // Determine whether we'll need to perform derived-to-base adjustments or
4339  // other conversions.
4340  bool NewDerivedToBase = false;
4341  bool NewObjCConversion = false;
4342  bool NewObjCLifetimeConversion = false;
4343  Sema::ReferenceCompareResult NewRefRelationship
4344  = S.CompareReferenceRelationship(DeclLoc, T1, cv3T3,
4345  NewDerivedToBase, NewObjCConversion,
4346  NewObjCLifetimeConversion);
4347 
4348  // Add the final conversion sequence, if necessary.
4349  if (NewRefRelationship == Sema::Ref_Incompatible) {
4350  assert(!isa<CXXConstructorDecl>(Function) &&
4351  "should not have conversion after constructor");
4352 
4354  ICS.setStandard();
4355  ICS.Standard = Best->FinalConversion;
4356  Sequence.AddConversionSequenceStep(ICS, ICS.Standard.getToType(2));
4357 
4358  // Every implicit conversion results in a prvalue, except for a glvalue
4359  // derived-to-base conversion, which we handle below.
4360  cv3T3 = ICS.Standard.getToType(2);
4361  VK = VK_RValue;
4362  }
4363 
4364  // If the converted initializer is a prvalue, its type T4 is adjusted to
4365  // type "cv1 T4" and the temporary materialization conversion is applied.
4366  //
4367  // We adjust the cv-qualifications to match the reference regardless of
4368  // whether we have a prvalue so that the AST records the change. In this
4369  // case, T4 is "cv3 T3".
4370  QualType cv1T4 = S.Context.getQualifiedType(cv3T3, cv1T1.getQualifiers());
4371  if (cv1T4.getQualifiers() != cv3T3.getQualifiers())
4372  Sequence.AddQualificationConversionStep(cv1T4, VK);
4373  Sequence.AddReferenceBindingStep(cv1T4, VK == VK_RValue);
4374  VK = IsLValueRef ? VK_LValue : VK_XValue;
4375 
4376  if (NewDerivedToBase)
4377  Sequence.AddDerivedToBaseCastStep(cv1T1, VK);
4378  else if (NewObjCConversion)
4379  Sequence.AddObjCObjectConversionStep(cv1T1);
4380 
4381  return OR_Success;
4382 }
4383 
4384 static void CheckCXX98CompatAccessibleCopy(Sema &S,
4385  const InitializedEntity &Entity,
4386  Expr *CurInitExpr);
4387 
4388 /// Attempt reference initialization (C++0x [dcl.init.ref])
4390  const InitializedEntity &Entity,
4391  const InitializationKind &Kind,
4392  Expr *Initializer,
4393  InitializationSequence &Sequence) {
4394  QualType DestType = Entity.getType();
4395  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
4396  Qualifiers T1Quals;
4397  QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
4398  QualType cv2T2 = Initializer->getType();
4399  Qualifiers T2Quals;
4400  QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
4401 
4402  // If the initializer is the address of an overloaded function, try
4403  // to resolve the overloaded function. If all goes well, T2 is the
4404  // type of the resulting function.
4405  if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
4406  T1, Sequence))
4407  return;
4408 
4409  // Delegate everything else to a subfunction.
4410  TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
4411  T1Quals, cv2T2, T2, T2Quals, Sequence);
4412 }
4413 
4414 /// Determine whether an expression is a non-referenceable glvalue (one to
4415 /// which a reference can never bind). Attempting to bind a reference to
4416 /// such a glvalue will always create a temporary.
4418  return E->refersToBitField() || E->refersToVectorElement();
4419 }
4420 
4421 /// Reference initialization without resolving overloaded functions.
4423  const InitializedEntity &Entity,
4424  const InitializationKind &Kind,
4425  Expr *Initializer,
4426  QualType cv1T1, QualType T1,
4427  Qualifiers T1Quals,
4428  QualType cv2T2, QualType T2,
4429  Qualifiers T2Quals,
4430  InitializationSequence &Sequence) {
4431  QualType DestType = Entity.getType();
4432  SourceLocation DeclLoc = Initializer->getLocStart();
4433  // Compute some basic properties of the types and the initializer.
4434  bool isLValueRef = DestType->isLValueReferenceType();
4435  bool isRValueRef = !isLValueRef;
4436  bool DerivedToBase = false;
4437  bool ObjCConversion = false;
4438  bool ObjCLifetimeConversion = false;
4439  Expr::Classification InitCategory = Initializer->Classify(S.Context);
4440  Sema::ReferenceCompareResult RefRelationship
4441  = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
4442  ObjCConversion, ObjCLifetimeConversion);
4443 
4444  // C++0x [dcl.init.ref]p5:
4445  // A reference to type "cv1 T1" is initialized by an expression of type
4446  // "cv2 T2" as follows:
4447  //
4448  // - If the reference is an lvalue reference and the initializer
4449  // expression
4450  // Note the analogous bullet points for rvalue refs to functions. Because
4451  // there are no function rvalues in C++, rvalue refs to functions are treated
4452  // like lvalue refs.
4453  OverloadingResult ConvOvlResult = OR_Success;
4454  bool T1Function = T1->isFunctionType();
4455  if (isLValueRef || T1Function) {
4456  if (InitCategory.isLValue() && !isNonReferenceableGLValue(Initializer) &&
4457  (RefRelationship == Sema::Ref_Compatible ||
4458  (Kind.isCStyleOrFunctionalCast() &&
4459  RefRelationship == Sema::Ref_Related))) {
4460  // - is an lvalue (but is not a bit-field), and "cv1 T1" is
4461  // reference-compatible with "cv2 T2," or
4462  if (T1Quals != T2Quals)
4463  // Convert to cv1 T2. This should only add qualifiers unless this is a
4464  // c-style cast. The removal of qualifiers in that case notionally
4465  // happens after the reference binding, but that doesn't matter.
4467  S.Context.getQualifiedType(T2, T1Quals),
4468  Initializer->getValueKind());
4469  if (DerivedToBase)
4470  Sequence.AddDerivedToBaseCastStep(cv1T1, VK_LValue);
4471  else if (ObjCConversion)
4472  Sequence.AddObjCObjectConversionStep(cv1T1);
4473 
4474  // We only create a temporary here when binding a reference to a
4475  // bit-field or vector element. Those cases are't supposed to be
4476  // handled by this bullet, but the outcome is the same either way.
4477  Sequence.AddReferenceBindingStep(cv1T1, false);
4478  return;
4479  }
4480 
4481  // - has a class type (i.e., T2 is a class type), where T1 is not
4482  // reference-related to T2, and can be implicitly converted to an
4483  // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
4484  // with "cv3 T3" (this conversion is selected by enumerating the
4485  // applicable conversion functions (13.3.1.6) and choosing the best
4486  // one through overload resolution (13.3)),
4487  // If we have an rvalue ref to function type here, the rhs must be
4488  // an rvalue. DR1287 removed the "implicitly" here.
4489  if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
4490  (isLValueRef || InitCategory.isRValue())) {
4491  ConvOvlResult = TryRefInitWithConversionFunction(
4492  S, Entity, Kind, Initializer, /*AllowRValues*/ isRValueRef,
4493  /*IsLValueRef*/ isLValueRef, Sequence);
4494  if (ConvOvlResult == OR_Success)
4495  return;
4496  if (ConvOvlResult != OR_No_Viable_Function)
4497  Sequence.SetOverloadFailure(
4499  ConvOvlResult);
4500  }
4501  }
4502 
4503  // - Otherwise, the reference shall be an lvalue reference to a
4504  // non-volatile const type (i.e., cv1 shall be const), or the reference
4505  // shall be an rvalue reference.
4506  if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
4507  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4509  else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4510  Sequence.SetOverloadFailure(
4512  ConvOvlResult);
4513  else if (!InitCategory.isLValue())
4514  Sequence.SetFailed(
4516  else {
4518  switch (RefRelationship) {
4519  case Sema::Ref_Compatible:
4520  if (Initializer->refersToBitField())
4521  FK = InitializationSequence::
4522  FK_NonConstLValueReferenceBindingToBitfield;
4523  else if (Initializer->refersToVectorElement())
4524  FK = InitializationSequence::
4525  FK_NonConstLValueReferenceBindingToVectorElement;
4526  else
4527  llvm_unreachable("unexpected kind of compatible initializer");
4528  break;
4529  case Sema::Ref_Related:
4531  break;
4535  break;
4536  }
4537  Sequence.SetFailed(FK);
4538  }
4539  return;
4540  }
4541 
4542  // - If the initializer expression
4543  // - is an
4544  // [<=14] xvalue (but not a bit-field), class prvalue, array prvalue, or
4545  // [1z] rvalue (but not a bit-field) or
4546  // function lvalue and "cv1 T1" is reference-compatible with "cv2 T2"
4547  //
4548  // Note: functions are handled above and below rather than here...
4549  if (!T1Function &&
4550  (RefRelationship == Sema::Ref_Compatible ||
4551  (Kind.isCStyleOrFunctionalCast() &&
4552  RefRelationship == Sema::Ref_Related)) &&
4553  ((InitCategory.isXValue() && !isNonReferenceableGLValue(Initializer)) ||
4554  (InitCategory.isPRValue() &&
4555  (S.getLangOpts().CPlusPlus17 || T2->isRecordType() ||
4556  T2->isArrayType())))) {
4557  ExprValueKind ValueKind = InitCategory.isXValue() ? VK_XValue : VK_RValue;
4558  if (InitCategory.isPRValue() && T2->isRecordType()) {
4559  // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
4560  // compiler the freedom to perform a copy here or bind to the
4561  // object, while C++0x requires that we bind directly to the
4562  // object. Hence, we always bind to the object without making an
4563  // extra copy. However, in C++03 requires that we check for the
4564  // presence of a suitable copy constructor:
4565  //
4566  // The constructor that would be used to make the copy shall
4567  // be callable whether or not the copy is actually done.
4568  if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
4569  Sequence.AddExtraneousCopyToTemporary(cv2T2);
4570  else if (S.getLangOpts().CPlusPlus11)
4571  CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
4572  }
4573 
4574  // C++1z [dcl.init.ref]/5.2.1.2:
4575  // If the converted initializer is a prvalue, its type T4 is adjusted
4576  // to type "cv1 T4" and the temporary materialization conversion is
4577  // applied.
4578  QualType cv1T4 = S.Context.getQualifiedType(cv2T2, T1Quals);
4579  if (T1Quals != T2Quals)
4580  Sequence.AddQualificationConversionStep(cv1T4, ValueKind);
4581  Sequence.AddReferenceBindingStep(cv1T4, ValueKind == VK_RValue);
4582  ValueKind = isLValueRef ? VK_LValue : VK_XValue;
4583 
4584  // In any case, the reference is bound to the resulting glvalue (or to
4585  // an appropriate base class subobject).
4586  if (DerivedToBase)
4587  Sequence.AddDerivedToBaseCastStep(cv1T1, ValueKind);
4588  else if (ObjCConversion)
4589  Sequence.AddObjCObjectConversionStep(cv1T1);
4590  return;
4591  }
4592 
4593  // - has a class type (i.e., T2 is a class type), where T1 is not
4594  // reference-related to T2, and can be implicitly converted to an
4595  // xvalue, class prvalue, or function lvalue of type "cv3 T3",
4596  // where "cv1 T1" is reference-compatible with "cv3 T3",
4597  //
4598  // DR1287 removes the "implicitly" here.
4599  if (T2->isRecordType()) {
4600  if (RefRelationship == Sema::Ref_Incompatible) {
4601  ConvOvlResult = TryRefInitWithConversionFunction(
4602  S, Entity, Kind, Initializer, /*AllowRValues*/ true,
4603  /*IsLValueRef*/ isLValueRef, Sequence);
4604  if (ConvOvlResult)
4605  Sequence.SetOverloadFailure(
4607  ConvOvlResult);
4608 
4609  return;
4610  }
4611 
4612  if (RefRelationship == Sema::Ref_Compatible &&
4613  isRValueRef && InitCategory.isLValue()) {
4614  Sequence.SetFailed(
4616  return;
4617  }
4618 
4620  return;
4621  }
4622 
4623  // - Otherwise, a temporary of type "cv1 T1" is created and initialized
4624  // from the initializer expression using the rules for a non-reference
4625  // copy-initialization (8.5). The reference is then bound to the
4626  // temporary. [...]
4627 
4629 
4630  // FIXME: Why do we use an implicit conversion here rather than trying
4631  // copy-initialization?
4633  = S.TryImplicitConversion(Initializer, TempEntity.getType(),
4634  /*SuppressUserConversions=*/false,
4635  /*AllowExplicit=*/false,
4636  /*FIXME:InOverloadResolution=*/false,
4637  /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4638  /*AllowObjCWritebackConversion=*/false);
4639 
4640  if (ICS.isBad()) {
4641  // FIXME: Use the conversion function set stored in ICS to turn
4642  // this into an overloading ambiguity diagnostic. However, we need
4643  // to keep that set as an OverloadCandidateSet rather than as some
4644  // other kind of set.
4645  if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4646  Sequence.SetOverloadFailure(
4648  ConvOvlResult);
4649  else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4651  else
4653  return;
4654  } else {
4655  Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
4656  }
4657 
4658  // [...] If T1 is reference-related to T2, cv1 must be the
4659  // same cv-qualification as, or greater cv-qualification
4660  // than, cv2; otherwise, the program is ill-formed.
4661  unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
4662  unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
4663  if (RefRelationship == Sema::Ref_Related &&
4664  (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
4666  return;
4667  }
4668 
4669  // [...] If T1 is reference-related to T2 and the reference is an rvalue
4670  // reference, the initializer expression shall not be an lvalue.
4671  if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
4672  InitCategory.isLValue()) {
4673  Sequence.SetFailed(
4675  return;
4676  }
4677 
4678  Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
4679 }
4680 
4681 /// Attempt character array initialization from a string literal
4682 /// (C++ [dcl.init.string], C99 6.7.8).
4684  const InitializedEntity &Entity,
4685  const InitializationKind &Kind,
4686  Expr *Initializer,
4687  InitializationSequence &Sequence) {
4688  Sequence.AddStringInitStep(Entity.getType());
4689 }
4690 
4691 /// Attempt value initialization (C++ [dcl.init]p7).
4693  const InitializedEntity &Entity,
4694  const InitializationKind &Kind,
4695  InitializationSequence &Sequence,
4696  InitListExpr *InitList) {
4697  assert((!InitList || InitList->getNumInits() == 0) &&
4698  "Shouldn't use value-init for non-empty init lists");
4699 
4700  // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
4701  //
4702  // To value-initialize an object of type T means:
4703  QualType T = Entity.getType();
4704 
4705  // -- if T is an array type, then each element is value-initialized;
4706  T = S.Context.getBaseElementType(T);
4707 
4708  if (const RecordType *RT = T->getAs<RecordType>()) {
4709  if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
4710  bool NeedZeroInitialization = true;
4711  // C++98:
4712  // -- if T is a class type (clause 9) with a user-declared constructor
4713  // (12.1), then the default constructor for T is called (and the
4714  // initialization is ill-formed if T has no accessible default
4715  // constructor);
4716  // C++11:
4717  // -- if T is a class type (clause 9) with either no default constructor
4718  // (12.1 [class.ctor]) or a default constructor that is user-provided
4719  // or deleted, then the object is default-initialized;
4720  //
4721  // Note that the C++11 rule is the same as the C++98 rule if there are no
4722  // defaulted or deleted constructors, so we just use it unconditionally.
4723  CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
4724  if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
4725  NeedZeroInitialization = false;
4726 
4727  // -- if T is a (possibly cv-qualified) non-union class type without a
4728  // user-provided or deleted default constructor, then the object is
4729  // zero-initialized and, if T has a non-trivial default constructor,
4730  // default-initialized;
4731  // The 'non-union' here was removed by DR1502. The 'non-trivial default
4732  // constructor' part was removed by DR1507.
4733  if (NeedZeroInitialization)
4734  Sequence.AddZeroInitializationStep(Entity.getType());
4735 
4736  // C++03:
4737  // -- if T is a non-union class type without a user-declared constructor,
4738  // then every non-static data member and base class component of T is
4739  // value-initialized;
4740  // [...] A program that calls for [...] value-initialization of an
4741  // entity of reference type is ill-formed.
4742  //
4743  // C++11 doesn't need this handling, because value-initialization does not
4744  // occur recursively there, and the implicit default constructor is
4745  // defined as deleted in the problematic cases.
4746  if (!S.getLangOpts().CPlusPlus11 &&
4747  ClassDecl->hasUninitializedReferenceMember()) {
4749  return;
4750  }
4751 
4752  // If this is list-value-initialization, pass the empty init list on when
4753  // building the constructor call. This affects the semantics of a few
4754  // things (such as whether an explicit default constructor can be called).
4755  Expr *InitListAsExpr = InitList;
4756  MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
4757  bool InitListSyntax = InitList;
4758 
4759  // FIXME: Instead of creating a CXXConstructExpr of array type here,
4760  // wrap a class-typed CXXConstructExpr in an ArrayInitLoopExpr.
4762  S, Entity, Kind, Args, T, Entity.getType(), Sequence, InitListSyntax);
4763  }
4764  }
4765 
4766  Sequence.AddZeroInitializationStep(Entity.getType());
4767 }
4768 
4769 /// Attempt default initialization (C++ [dcl.init]p6).
4771  const InitializedEntity &Entity,
4772  const InitializationKind &Kind,
4773  InitializationSequence &Sequence) {
4774  assert(Kind.getKind() == InitializationKind::IK_Default);
4775 
4776  // C++ [dcl.init]p6:
4777  // To default-initialize an object of type T means:
4778  // - if T is an array type, each element is default-initialized;
4779  QualType DestType = S.Context.getBaseElementType(Entity.getType());
4780 
4781  // - if T is a (possibly cv-qualified) class type (Clause 9), the default
4782  // constructor for T is called (and the initialization is ill-formed if
4783  // T has no accessible default constructor);
4784  if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
4785  TryConstructorInitialization(S, Entity, Kind, None, DestType,
4786  Entity.getType(), Sequence);
4787  return;
4788  }
4789 
4790  // - otherwise, no initialization is performed.
4791 
4792  // If a program calls for the default initialization of an object of
4793  // a const-qualified type T, T shall be a class type with a user-provided
4794  // default constructor.
4795  if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
4796  if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
4798  return;
4799  }
4800 
4801  // If the destination type has a lifetime property, zero-initialize it.
4802  if (DestType.getQualifiers().hasObjCLifetime()) {
4803  Sequence.AddZeroInitializationStep(Entity.getType());
4804  return;
4805  }
4806 }
4807 
4808 /// Attempt a user-defined conversion between two types (C++ [dcl.init]),
4809 /// which enumerates all conversion functions and performs overload resolution
4810 /// to select the best.
4812  QualType DestType,
4813  const InitializationKind &Kind,
4814  Expr *Initializer,
4815  InitializationSequence &Sequence,
4816  bool TopLevelOfInitList) {
4817  assert(!DestType->isReferenceType() && "References are handled elsewhere");
4818  QualType SourceType = Initializer->getType();
4819  assert((DestType->isRecordType() || SourceType->isRecordType()) &&
4820  "Must have a class type to perform a user-defined conversion");
4821 
4822  // Build the candidate set directly in the initialization sequence
4823  // structure, so that it will persist if we fail.
4824  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4826 
4827  // Determine whether we are allowed to call explicit constructors or
4828  // explicit conversion operators.
4829  bool AllowExplicit = Kind.AllowExplicit();
4830 
4831  if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4832  // The type we're converting to is a class type. Enumerate its constructors
4833  // to see if there is a suitable conversion.
4834  CXXRecordDecl *DestRecordDecl
4835  = cast<CXXRecordDecl>(DestRecordType->getDecl());
4836 
4837  // Try to complete the type we're converting to.
4838  if (S.isCompleteType(Kind.getLocation(), DestType)) {
4839  for (NamedDecl *D : S.LookupConstructors(DestRecordDecl)) {
4840  auto Info = getConstructorInfo(D);
4841  if (!Info.Constructor)
4842  continue;
4843 
4844  if (!Info.Constructor->isInvalidDecl() &&
4845  Info.Constructor->isConvertingConstructor(AllowExplicit)) {
4846  if (Info.ConstructorTmpl)
4847  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
4848  /*ExplicitArgs*/ nullptr,
4849  Initializer, CandidateSet,
4850  /*SuppressUserConversions=*/true);
4851  else
4852  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
4853  Initializer, CandidateSet,
4854  /*SuppressUserConversions=*/true);
4855  }
4856  }
4857  }
4858  }
4859 
4860  SourceLocation DeclLoc = Initializer->getLocStart();
4861 
4862  if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
4863  // The type we're converting from is a class type, enumerate its conversion
4864  // functions.
4865 
4866  // We can only enumerate the conversion functions for a complete type; if
4867  // the type isn't complete, simply skip this step.
4868  if (S.isCompleteType(DeclLoc, SourceType)) {
4869  CXXRecordDecl *SourceRecordDecl
4870  = cast<CXXRecordDecl>(SourceRecordType->getDecl());
4871 
4872  const auto &Conversions =
4873  SourceRecordDecl->getVisibleConversionFunctions();
4874  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4875  NamedDecl *D = *I;
4876  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4877  if (isa<UsingShadowDecl>(D))
4878  D = cast<UsingShadowDecl>(D)->getTargetDecl();
4879 
4880  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4881  CXXConversionDecl *Conv;
4882  if (ConvTemplate)
4883  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4884  else
4885  Conv = cast<CXXConversionDecl>(D);
4886 
4887  if (AllowExplicit || !Conv->isExplicit()) {
4888  if (ConvTemplate)
4889  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4890  ActingDC, Initializer, DestType,
4891  CandidateSet, AllowExplicit);
4892  else
4893  S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4894  Initializer, DestType, CandidateSet,
4895  AllowExplicit);
4896  }
4897  }
4898  }
4899  }
4900 
4901  // Perform overload resolution. If it fails, return the failed result.
4904  = CandidateSet.BestViableFunction(S, DeclLoc, Best)) {
4905  Sequence.SetOverloadFailure(
4907  Result);
4908  return;
4909  }
4910 
4911  FunctionDecl *Function = Best->Function;
4912  Function->setReferenced();
4913  bool HadMultipleCandidates = (CandidateSet.size() > 1);
4914 
4915  if (isa<CXXConstructorDecl>(Function)) {
4916  // Add the user-defined conversion step. Any cv-qualification conversion is
4917  // subsumed by the initialization. Per DR5, the created temporary is of the
4918  // cv-unqualified type of the destination.
4919  Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4920  DestType.getUnqualifiedType(),
4921  HadMultipleCandidates);
4922 
4923  // C++14 and before:
4924  // - if the function is a constructor, the call initializes a temporary
4925  // of the cv-unqualified version of the destination type. The [...]
4926  // temporary [...] is then used to direct-initialize, according to the
4927  // rules above, the object that is the destination of the
4928  // copy-initialization.
4929  // Note that this just performs a simple object copy from the temporary.
4930  //
4931  // C++17:
4932  // - if the function is a constructor, the call is a prvalue of the
4933  // cv-unqualified version of the destination type whose return object
4934  // is initialized by the constructor. The call is used to
4935  // direct-initialize, according to the rules above, the object that
4936  // is the destination of the copy-initialization.
4937  // Therefore we need to do nothing further.
4938  //
4939  // FIXME: Mark this copy as extraneous.
4940  if (!S.getLangOpts().CPlusPlus17)
4941  Sequence.AddFinalCopy(DestType);
4942  else if (DestType.hasQualifiers())
4943  Sequence.AddQualificationConversionStep(DestType, VK_RValue);
4944  return;
4945  }
4946 
4947  // Add the user-defined conversion step that calls the conversion function.
4948  QualType ConvType = Function->getCallResultType();
4949  Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
4950  HadMultipleCandidates);
4951 
4952  if (ConvType->getAs<RecordType>()) {
4953  // The call is used to direct-initialize [...] the object that is the
4954  // destination of the copy-initialization.
4955  //
4956  // In C++17, this does not call a constructor if we enter /17.6.1:
4957  // - If the initializer expression is a prvalue and the cv-unqualified
4958  // version of the source type is the same as the class of the
4959  // destination [... do not make an extra copy]
4960  //
4961  // FIXME: Mark this copy as extraneous.
4962  if (!S.getLangOpts().CPlusPlus17 ||
4963  Function->getReturnType()->isReferenceType() ||
4964  !S.Context.hasSameUnqualifiedType(ConvType, DestType))
4965  Sequence.AddFinalCopy(DestType);
4966  else if (!S.Context.hasSameType(ConvType, DestType))
4967  Sequence.AddQualificationConversionStep(DestType, VK_RValue);
4968  return;
4969  }
4970 
4971  // If the conversion following the call to the conversion function
4972  // is interesting, add it as a separate step.
4973  if (Best->FinalConversion.First || Best->FinalConversion.Second ||
4974  Best->FinalConversion.Third) {
4976  ICS.setStandard();
4977  ICS.Standard = Best->FinalConversion;
4978  Sequence.AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
4979  }
4980 }
4981 
4982 /// An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>,
4983 /// a function with a pointer return type contains a 'return false;' statement.
4984 /// In C++11, 'false' is not a null pointer, so this breaks the build of any
4985 /// code using that header.
4986 ///
4987 /// Work around this by treating 'return false;' as zero-initializing the result
4988 /// if it's used in a pointer-returning function in a system header.
4990  const InitializedEntity &Entity,
4991  const Expr *Init) {
4992  return S.getLangOpts().CPlusPlus11 &&
4993  Entity.getKind() == InitializedEntity::EK_Result &&
4994  Entity.getType()->isPointerType() &&
4995  isa<CXXBoolLiteralExpr>(Init) &&
4996  !cast<CXXBoolLiteralExpr>(Init)->getValue() &&
4998 }
4999 
5000 /// The non-zero enum values here are indexes into diagnostic alternatives.
5002 
5003 /// Determines whether this expression is an acceptable ICR source.
5005  bool isAddressOf, bool &isWeakAccess) {
5006  // Skip parens.
5007  e = e->IgnoreParens();
5008 
5009  // Skip address-of nodes.
5010  if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
5011  if (op->getOpcode() == UO_AddrOf)
5012  return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
5013  isWeakAccess);
5014 
5015  // Skip certain casts.
5016  } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
5017  switch (ce->getCastKind()) {
5018  case CK_Dependent:
5019  case CK_BitCast:
5020  case CK_LValueBitCast:
5021  case CK_NoOp:
5022  return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
5023 
5024  case CK_ArrayToPointerDecay:
5025  return IIK_nonscalar;
5026 
5027  case CK_NullToPointer:
5028  return IIK_okay;
5029 
5030  default:
5031  break;
5032  }
5033 
5034  // If we have a declaration reference, it had better be a local variable.
5035  } else if (isa<DeclRefExpr>(e)) {
5036  // set isWeakAccess to true, to mean that there will be an implicit
5037  // load which requires a cleanup.
5039  isWeakAccess = true;
5040 
5041  if (!isAddressOf) return IIK_nonlocal;
5042 
5043  VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
5044  if (!var) return IIK_nonlocal;
5045 
5046  return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
5047 
5048  // If we have a conditional operator, check both sides.
5049  } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
5050  if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
5051  isWeakAccess))
5052  return iik;
5053 
5054  return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
5055 
5056  // These are never scalar.
5057  } else if (isa<ArraySubscriptExpr>(e)) {
5058  return IIK_nonscalar;
5059 
5060  // Otherwise, it needs to be a null pointer constant.
5061  } else {
5063  ? IIK_okay : IIK_nonlocal);
5064  }
5065 
5066  return IIK_nonlocal;
5067 }
5068 
5069 /// Check whether the given expression is a valid operand for an
5070 /// indirect copy/restore.
5072  assert(src->isRValue());
5073  bool isWeakAccess = false;
5074  InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
5075  // If isWeakAccess to true, there will be an implicit
5076  // load which requires a cleanup.
5077  if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
5078  S.Cleanup.setExprNeedsCleanups(true);
5079 
5080  if (iik == IIK_okay) return;
5081 
5082  S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
5083  << ((unsigned) iik - 1) // shift index into diagnostic explanations
5084  << src->getSourceRange();
5085 }
5086 
5087 /// Determine whether we have compatible array types for the
5088 /// purposes of GNU by-copy array initialization.
5089 static bool hasCompatibleArrayTypes(ASTContext &Context, const ArrayType *Dest,
5090  const ArrayType *Source) {
5091  // If the source and destination array types are equivalent, we're
5092  // done.
5093  if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
5094  return true;
5095 
5096  // Make sure that the element types are the same.
5097  if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
5098  return false;
5099 
5100  // The only mismatch we allow is when the destination is an
5101  // incomplete array type and the source is a constant array type.
5102  return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
5103 }
5104 
5106  InitializationSequence &Sequence,
5107  const InitializedEntity &Entity,
5108  Expr *Initializer) {
5109  bool ArrayDecay = false;
5110  QualType ArgType = Initializer->getType();
5111  QualType ArgPointee;
5112  if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
5113  ArrayDecay = true;
5114  ArgPointee = ArgArrayType->getElementType();
5115  ArgType = S.Context.getPointerType(ArgPointee);
5116  }
5117 
5118  // Handle write-back conversion.
5119  QualType ConvertedArgType;
5120  if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
5121  ConvertedArgType))
5122  return false;
5123 
5124  // We should copy unless we're passing to an argument explicitly
5125  // marked 'out'.
5126  bool ShouldCopy = true;
5127  if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
5128  ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
5129 
5130  // Do we need an lvalue conversion?
5131  if (ArrayDecay || Initializer->isGLValue()) {
5133  ICS.setStandard();
5135 
5136  QualType ResultType;
5137  if (ArrayDecay) {
5139  ResultType = S.Context.getPointerType(ArgPointee);
5140  } else {
5142  ResultType = Initializer->getType().getNonLValueExprType(S.Context);
5143  }
5144 
5145  Sequence.AddConversionSequenceStep(ICS, ResultType);
5146  }
5147 
5148  Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
5149  return true;
5150 }
5151 
5153  InitializationSequence &Sequence,
5154  QualType DestType,
5155  Expr *Initializer) {
5156  if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
5157  (!Initializer->isIntegerConstantExpr(S.Context) &&
5158  !Initializer->getType()->isSamplerT()))
5159  return false;
5160 
5161  Sequence.AddOCLSamplerInitStep(DestType);
5162  return true;
5163 }
5164 
5165 //
5166 // OpenCL 1.2 spec, s6.12.10
5167 //
5168 // The event argument can also be used to associate the
5169 // async_work_group_copy with a previous async copy allowing
5170 // an event to be shared by multiple async copies; otherwise
5171 // event should be zero.
5172 //
5174  InitializationSequence &Sequence,
5175  QualType DestType,
5176  Expr *Initializer) {
5177  if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
5178  !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
5179  (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
5180  return false;
5181 
5182  Sequence.AddOCLZeroEventStep(DestType);
5183  return true;
5184 }
5185 
5187  InitializationSequence &Sequence,
5188  QualType DestType,
5189  Expr *Initializer) {
5190  if (!S.getLangOpts().OpenCL || S.getLangOpts().OpenCLVersion < 200 ||
5191  !DestType->isQueueT() ||
5192  !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
5193  (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
5194  return false;
5195 
5196  Sequence.AddOCLZeroQueueStep(DestType);
5197  return true;
5198 }
5199 
5201  const InitializedEntity &Entity,
5202  const InitializationKind &Kind,
5203  MultiExprArg Args,
5204  bool TopLevelOfInitList,
5205  bool TreatUnavailableAsInvalid)
5206  : FailedCandidateSet(Kind.getLocation(), OverloadCandidateSet::CSK_Normal) {
5207  InitializeFrom(S, Entity, Kind, Args, TopLevelOfInitList,
5208  TreatUnavailableAsInvalid);
5209 }
5210 
5211 /// Tries to get a FunctionDecl out of `E`. If it succeeds and we can take the
5212 /// address of that function, this returns true. Otherwise, it returns false.
5213 static bool isExprAnUnaddressableFunction(Sema &S, const Expr *E) {
5214  auto *DRE = dyn_cast<DeclRefExpr>(E);
5215  if (!DRE || !isa<FunctionDecl>(DRE->getDecl()))
5216  return false;
5217 
5219  cast<FunctionDecl>(DRE->getDecl()));
5220 }
5221 
5222 /// Determine whether we can perform an elementwise array copy for this kind
5223 /// of entity.
5224 static bool canPerformArrayCopy(const InitializedEntity &Entity) {
5225  switch (Entity.getKind()) {
5227  // C++ [expr.prim.lambda]p24:
5228  // For array members, the array elements are direct-initialized in
5229  // increasing subscript order.
5230  return true;
5231 
5233  // C++ [dcl.decomp]p1:
5234  // [...] each element is copy-initialized or direct-initialized from the
5235  // corresponding element of the assignment-expression [...]
5236  return isa<DecompositionDecl>(Entity.getDecl());
5237 
5239  // C++ [class.copy.ctor]p14:
5240  // - if the member is an array, each element is direct-initialized with
5241  // the corresponding subobject of x
5242  return Entity.isImplicitMemberInitializer();
5243 
5245  // All the above cases are intended to apply recursively, even though none
5246  // of them actually say that.
5247  if (auto *E = Entity.getParent())
5248  return canPerformArrayCopy(*E);
5249  break;
5250 
5251  default:
5252  break;
5253  }
5254 
5255  return false;
5256 }
5257 
5259  const InitializedEntity &Entity,
5260  const InitializationKind &Kind,
5261  MultiExprArg Args,
5262  bool TopLevelOfInitList,
5263  bool TreatUnavailableAsInvalid) {
5264  ASTContext &Context = S.Context;
5265 
5266  // Eliminate non-overload placeholder types in the arguments. We
5267  // need to do this before checking whether types are dependent
5268  // because lowering a pseudo-object expression might well give us
5269  // something of dependent type.
5270  for (unsigned I = 0, E = Args.size(); I != E; ++I)
5271  if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
5272  // FIXME: should we be doing this here?
5273  ExprResult result = S.CheckPlaceholderExpr(Args[I]);
5274  if (result.isInvalid()) {
5276  return;
5277  }
5278  Args[I] = result.get();
5279  }
5280 
5281  // C++0x [dcl.init]p16:
5282  // The semantics of initializers are as follows. The destination type is
5283  // the type of the object or reference being initialized and the source
5284  // type is the type of the initializer expression. The source type is not
5285  // defined when the initializer is a braced-init-list or when it is a
5286  // parenthesized list of expressions.
5287  QualType DestType = Entity.getType();
5288 
5289  if (DestType->isDependentType() ||
5292  return;
5293  }
5294 
5295  // Almost everything is a normal sequence.
5297 
5298  QualType SourceType;
5299  Expr *Initializer = nullptr;
5300  if (Args.size() == 1) {
5301  Initializer = Args[0];
5302  if (S.getLangOpts().ObjC1) {
5303  if (S.CheckObjCBridgeRelatedConversions(Initializer->getLocStart(),
5304  DestType, Initializer->getType(),
5305  Initializer) ||
5306  S.ConversionToObjCStringLiteralCheck(DestType, Initializer))
5307  Args[0] = Initializer;
5308  }
5309  if (!isa<InitListExpr>(Initializer))
5310  SourceType = Initializer->getType();
5311  }
5312 
5313  // - If the initializer is a (non-parenthesized) braced-init-list, the
5314  // object is list-initialized (8.5.4).
5315  if (Kind.getKind() != InitializationKind::IK_Direct) {
5316  if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
5317  TryListInitialization(S, Entity, Kind, InitList, *this,
5318  TreatUnavailableAsInvalid);
5319  return;
5320  }
5321  }
5322 
5323  // - If the destination type is a reference type, see 8.5.3.
5324  if (DestType->isReferenceType()) {
5325  // C++0x [dcl.init.ref]p1:
5326  // A variable declared to be a T& or T&&, that is, "reference to type T"
5327  // (8.3.2), shall be initialized by an object, or function, of type T or
5328  // by an object that can be converted into a T.
5329  // (Therefore, multiple arguments are not permitted.)
5330  if (Args.size() != 1)
5332  // C++17 [dcl.init.ref]p5:
5333  // A reference [...] is initialized by an expression [...] as follows:
5334  // If the initializer is not an expression, presumably we should reject,
5335  // but the standard fails to actually say so.
5336  else if (isa<InitListExpr>(Args[0]))
5338  else
5339  TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
5340  return;
5341  }
5342 
5343  // - If the initializer is (), the object is value-initialized.
5344  if (Kind.getKind() == InitializationKind::IK_Value ||
5345  (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
5346  TryValueInitialization(S, Entity, Kind, *this);
5347  return;
5348  }
5349 
5350  // Handle default initialization.
5351  if (Kind.getKind() == InitializationKind::IK_Default) {
5352  TryDefaultInitialization(S, Entity, Kind, *this);
5353  return;
5354  }
5355 
5356  // - If the destination type is an array of characters, an array of
5357  // char16_t, an array of char32_t, or an array of wchar_t, and the
5358  // initializer is a string literal, see 8.5.2.
5359  // - Otherwise, if the destination type is an array, the program is
5360  // ill-formed.
5361  if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
5362  if (Initializer && isa<VariableArrayType>(DestAT)) {
5364  return;
5365  }
5366 
5367  if (Initializer) {
5368  switch (IsStringInit(Initializer, DestAT, Context)) {
5369  case SIF_None:
5370  TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
5371  return;
5374  return;
5377  return;
5380  return;
5383  return;
5386  return;
5387  case SIF_Other:
5388  break;
5389  }
5390  }
5391 
5392  // Some kinds of initialization permit an array to be initialized from
5393  // another array of the same type, and perform elementwise initialization.
5394  if (Initializer && isa<ConstantArrayType>(DestAT) &&
5395  S.Context.hasSameUnqualifiedType(Initializer->getType(),
5396  Entity.getType()) &&
5397  canPerformArrayCopy(Entity)) {
5398  // If source is a prvalue, use it directly.
5399  if (Initializer->getValueKind() == VK_RValue) {
5400  AddArrayInitStep(DestType, /*IsGNUExtension*/false);
5401  return;
5402  }
5403 
5404  // Emit element-at-a-time copy loop.
5405  InitializedEntity Element =
5407  QualType InitEltT =
5408  Context.getAsArrayType(Initializer->getType())->getElementType();
5409  OpaqueValueExpr OVE(Initializer->getExprLoc(), InitEltT,
5410  Initializer->getValueKind(),
5411  Initializer->getObjectKind());
5412  Expr *OVEAsExpr = &OVE;
5413  InitializeFrom(S, Element, Kind, OVEAsExpr, TopLevelOfInitList,
5414  TreatUnavailableAsInvalid);
5415  if (!Failed())
5416  AddArrayInitLoopStep(Entity.getType(), InitEltT);
5417  return;
5418  }
5419 
5420  // Note: as an GNU C extension, we allow initialization of an
5421  // array from a compound literal that creates an array of the same
5422  // type, so long as the initializer has no side effects.
5423  if (!S.getLangOpts().CPlusPlus && Initializer &&
5424  isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
5425  Initializer->getType()->isArrayType()) {
5426  const ArrayType *SourceAT
5427  = Context.getAsArrayType(Initializer->getType());
5428  if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
5430  else if (Initializer->HasSideEffects(S.Context))
5432  else {
5433  AddArrayInitStep(DestType, /*IsGNUExtension*/true);
5434  }
5435  }
5436  // Note: as a GNU C++ extension, we allow list-initialization of a
5437  // class member of array type from a parenthesized initializer list.
5438  else if (S.getLangOpts().CPlusPlus &&
5439  Entity.getKind() == InitializedEntity::EK_Member &&
5440  Initializer && isa<InitListExpr>(Initializer)) {
5441  TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
5442  *this, TreatUnavailableAsInvalid);
5444  } else if (DestAT->getElementType()->isCharType())
5446  else if (IsWideCharCompatible(DestAT->getElementType(), Context))
5448  else
5450 
5451  return;
5452  }
5453 
5454  // Determine whether we should consider writeback conversions for
5455  // Objective-C ARC.
5456  bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
5457  Entity.isParameterKind();
5458 
5459  // We're at the end of the line for C: it's either a write-back conversion
5460  // or it's a C assignment. There's no need to check anything else.
5461  if (!S.getLangOpts().CPlusPlus) {
5462  // If allowed, check whether this is an Objective-C writeback conversion.
5463  if (allowObjCWritebackConversion &&
5464  tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
5465  return;
5466  }
5467 
5468  if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
5469  return;
5470 
5471  if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
5472  return;
5473 
5474  if (TryOCLZeroQueueInitialization(S, *this, DestType, Initializer))
5475  return;
5476 
5477  // Handle initialization in C
5478  AddCAssignmentStep(DestType);
5479  MaybeProduceObjCObject(S, *this, Entity);
5480  return;
5481  }
5482 
5483  assert(S.getLangOpts().CPlusPlus);
5484 
5485  // - If the destination type is a (possibly cv-qualified) class type:
5486  if (DestType->isRecordType()) {
5487  // - If the initialization is direct-initialization, or if it is
5488  // copy-initialization where the cv-unqualified version of the
5489  // source type is the same class as, or a derived class of, the
5490  // class of the destination, constructors are considered. [...]
5491  if (Kind.getKind() == InitializationKind::IK_Direct ||
5492  (Kind.getKind() == InitializationKind::IK_Copy &&
5493  (Context.hasSameUnqualifiedType(SourceType, DestType) ||
5494  S.IsDerivedFrom(Initializer->getLocStart(), SourceType, DestType))))
5495  TryConstructorInitialization(S, Entity, Kind, Args,
5496  DestType, DestType, *this);
5497  // - Otherwise (i.e., for the remaining copy-initialization cases),
5498  // user-defined conversion sequences that can convert from the source
5499  // type to the destination type or (when a conversion function is
5500  // used) to a derived class thereof are enumerated as described in
5501  // 13.3.1.4, and the best one is chosen through overload resolution
5502  // (13.3).
5503  else
5504  TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5505  TopLevelOfInitList);
5506  return;
5507  }
5508 
5509  assert(Args.size() >= 1 && "Zero-argument case handled above");
5510 
5511  // The remaining cases all need a source type.
5512  if (Args.size() > 1) {
5514  return;
5515  } else if (isa<InitListExpr>(Args[0])) {
5517  return;
5518  }
5519 
5520  // - Otherwise, if the source type is a (possibly cv-qualified) class
5521  // type, conversion functions are considered.
5522  if (!SourceType.isNull() && SourceType->isRecordType()) {
5523  // For a conversion to _Atomic(T) from either T or a class type derived
5524  // from T, initialize the T object then convert to _Atomic type.
5525  bool NeedAtomicConversion = false;
5526  if (const AtomicType *Atomic = DestType->getAs<AtomicType>()) {
5527  if (Context.hasSameUnqualifiedType(SourceType, Atomic->getValueType()) ||
5528  S.IsDerivedFrom(Initializer->getLocStart(), SourceType,
5529  Atomic->getValueType())) {
5530  DestType = Atomic->getValueType();
5531  NeedAtomicConversion = true;
5532  }
5533  }
5534 
5535  TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5536  TopLevelOfInitList);
5537  MaybeProduceObjCObject(S, *this, Entity);
5538  if (!Failed() && NeedAtomicConversion)
5539  AddAtomicConversionStep(Entity.getType());
5540  return;
5541  }
5542 
5543  // - Otherwise, the initial value of the object being initialized is the