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