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