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 final : 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  std::unique_ptr<CorrectionCandidateCallback> clone() override {
2222  return llvm::make_unique<FieldInitializerValidatorCCC>(*this);
2223  }
2224 
2225  private:
2226  RecordDecl *Record;
2227 };
2228 
2229 } // end anonymous namespace
2230 
2231 /// Check the well-formedness of a C99 designated initializer.
2232 ///
2233 /// Determines whether the designated initializer @p DIE, which
2234 /// resides at the given @p Index within the initializer list @p
2235 /// IList, is well-formed for a current object of type @p DeclType
2236 /// (C99 6.7.8). The actual subobject that this designator refers to
2237 /// within the current subobject is returned in either
2238 /// @p NextField or @p NextElementIndex (whichever is appropriate).
2239 ///
2240 /// @param IList The initializer list in which this designated
2241 /// initializer occurs.
2242 ///
2243 /// @param DIE The designated initializer expression.
2244 ///
2245 /// @param DesigIdx The index of the current designator.
2246 ///
2247 /// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
2248 /// into which the designation in @p DIE should refer.
2249 ///
2250 /// @param NextField If non-NULL and the first designator in @p DIE is
2251 /// a field, this will be set to the field declaration corresponding
2252 /// to the field named by the designator.
2253 ///
2254 /// @param NextElementIndex If non-NULL and the first designator in @p
2255 /// DIE is an array designator or GNU array-range designator, this
2256 /// will be set to the last index initialized by this designator.
2257 ///
2258 /// @param Index Index into @p IList where the designated initializer
2259 /// @p DIE occurs.
2260 ///
2261 /// @param StructuredList The initializer list expression that
2262 /// describes all of the subobject initializers in the order they'll
2263 /// actually be initialized.
2264 ///
2265 /// @returns true if there was an error, false otherwise.
2266 bool
2267 InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
2268  InitListExpr *IList,
2269  DesignatedInitExpr *DIE,
2270  unsigned DesigIdx,
2271  QualType &CurrentObjectType,
2272  RecordDecl::field_iterator *NextField,
2273  llvm::APSInt *NextElementIndex,
2274  unsigned &Index,
2275  InitListExpr *StructuredList,
2276  unsigned &StructuredIndex,
2277  bool FinishSubobjectInit,
2278  bool TopLevelObject) {
2279  if (DesigIdx == DIE->size()) {
2280  // Check the actual initialization for the designated object type.
2281  bool prevHadError = hadError;
2282 
2283  // Temporarily remove the designator expression from the
2284  // initializer list that the child calls see, so that we don't try
2285  // to re-process the designator.
2286  unsigned OldIndex = Index;
2287  IList->setInit(OldIndex, DIE->getInit());
2288 
2289  CheckSubElementType(Entity, IList, CurrentObjectType, Index,
2290  StructuredList, StructuredIndex);
2291 
2292  // Restore the designated initializer expression in the syntactic
2293  // form of the initializer list.
2294  if (IList->getInit(OldIndex) != DIE->getInit())
2295  DIE->setInit(IList->getInit(OldIndex));
2296  IList->setInit(OldIndex, DIE);
2297 
2298  return hadError && !prevHadError;
2299  }
2300 
2301  DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
2302  bool IsFirstDesignator = (DesigIdx == 0);
2303  if (!VerifyOnly) {
2304  assert((IsFirstDesignator || StructuredList) &&
2305  "Need a non-designated initializer list to start from");
2306 
2307  // Determine the structural initializer list that corresponds to the
2308  // current subobject.
2309  if (IsFirstDesignator)
2310  StructuredList = SyntacticToSemantic.lookup(IList);
2311  else {
2312  Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2313  StructuredList->getInit(StructuredIndex) : nullptr;
2314  if (!ExistingInit && StructuredList->hasArrayFiller())
2315  ExistingInit = StructuredList->getArrayFiller();
2316 
2317  if (!ExistingInit)
2318  StructuredList = getStructuredSubobjectInit(
2319  IList, Index, CurrentObjectType, StructuredList, StructuredIndex,
2320  SourceRange(D->getBeginLoc(), DIE->getEndLoc()));
2321  else if (InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2322  StructuredList = Result;
2323  else {
2324  if (DesignatedInitUpdateExpr *E =
2325  dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2326  StructuredList = E->getUpdater();
2327  else {
2328  DesignatedInitUpdateExpr *DIUE = new (SemaRef.Context)
2330  ExistingInit, DIE->getEndLoc());
2331  StructuredList->updateInit(SemaRef.Context, StructuredIndex, DIUE);
2332  StructuredList = DIUE->getUpdater();
2333  }
2334 
2335  // We need to check on source range validity because the previous
2336  // initializer does not have to be an explicit initializer. e.g.,
2337  //
2338  // struct P { int a, b; };
2339  // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2340  //
2341  // There is an overwrite taking place because the first braced initializer
2342  // list "{ .a = 2 }" already provides value for .p.b (which is zero).
2343  if (ExistingInit->getSourceRange().isValid()) {
2344  // We are creating an initializer list that initializes the
2345  // subobjects of the current object, but there was already an
2346  // initialization that completely initialized the current
2347  // subobject, e.g., by a compound literal:
2348  //
2349  // struct X { int a, b; };
2350  // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2351  //
2352  // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2353  // designated initializer re-initializes the whole
2354  // subobject [0], overwriting previous initializers.
2355  SemaRef.Diag(D->getBeginLoc(),
2356  diag::warn_subobject_initializer_overrides)
2357  << SourceRange(D->getBeginLoc(), DIE->getEndLoc());
2358 
2359  SemaRef.Diag(ExistingInit->getBeginLoc(),
2360  diag::note_previous_initializer)
2361  << /*FIXME:has side effects=*/0 << ExistingInit->getSourceRange();
2362  }
2363  }
2364  }
2365  assert(StructuredList && "Expected a structured initializer list");
2366  }
2367 
2368  if (D->isFieldDesignator()) {
2369  // C99 6.7.8p7:
2370  //
2371  // If a designator has the form
2372  //
2373  // . identifier
2374  //
2375  // then the current object (defined below) shall have
2376  // structure or union type and the identifier shall be the
2377  // name of a member of that type.
2378  const RecordType *RT = CurrentObjectType->getAs<RecordType>();
2379  if (!RT) {
2380  SourceLocation Loc = D->getDotLoc();
2381  if (Loc.isInvalid())
2382  Loc = D->getFieldLoc();
2383  if (!VerifyOnly)
2384  SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
2385  << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
2386  ++Index;
2387  return true;
2388  }
2389 
2390  FieldDecl *KnownField = D->getField();
2391  if (!KnownField) {
2392  IdentifierInfo *FieldName = D->getFieldName();
2393  DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
2394  for (NamedDecl *ND : Lookup) {
2395  if (auto *FD = dyn_cast<FieldDecl>(ND)) {
2396  KnownField = FD;
2397  break;
2398  }
2399  if (auto *IFD = dyn_cast<IndirectFieldDecl>(ND)) {
2400  // In verify mode, don't modify the original.
2401  if (VerifyOnly)
2402  DIE = CloneDesignatedInitExpr(SemaRef, DIE);
2403  ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IFD);
2404  D = DIE->getDesignator(DesigIdx);
2405  KnownField = cast<FieldDecl>(*IFD->chain_begin());
2406  break;
2407  }
2408  }
2409  if (!KnownField) {
2410  if (VerifyOnly) {
2411  ++Index;
2412  return true; // No typo correction when just trying this out.
2413  }
2414 
2415  // Name lookup found something, but it wasn't a field.
2416  if (!Lookup.empty()) {
2417  SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
2418  << FieldName;
2419  SemaRef.Diag(Lookup.front()->getLocation(),
2420  diag::note_field_designator_found);
2421  ++Index;
2422  return true;
2423  }
2424 
2425  // Name lookup didn't find anything.
2426  // Determine whether this was a typo for another field name.
2427  FieldInitializerValidatorCCC CCC(RT->getDecl());
2428  if (TypoCorrection Corrected = SemaRef.CorrectTypo(
2429  DeclarationNameInfo(FieldName, D->getFieldLoc()),
2430  Sema::LookupMemberName, /*Scope=*/nullptr, /*SS=*/nullptr, CCC,
2431  Sema::CTK_ErrorRecovery, RT->getDecl())) {
2432  SemaRef.diagnoseTypo(
2433  Corrected,
2434  SemaRef.PDiag(diag::err_field_designator_unknown_suggest)
2435  << FieldName << CurrentObjectType);
2436  KnownField = Corrected.getCorrectionDeclAs<FieldDecl>();
2437  hadError = true;
2438  } else {
2439  // Typo correction didn't find anything.
2440  SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
2441  << FieldName << CurrentObjectType;
2442  ++Index;
2443  return true;
2444  }
2445  }
2446  }
2447 
2448  unsigned FieldIndex = 0;
2449 
2450  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
2451  FieldIndex = CXXRD->getNumBases();
2452 
2453  for (auto *FI : RT->getDecl()->fields()) {
2454  if (FI->isUnnamedBitfield())
2455  continue;
2456  if (declaresSameEntity(KnownField, FI)) {
2457  KnownField = FI;
2458  break;
2459  }
2460  ++FieldIndex;
2461  }
2462 
2465 
2466  // All of the fields of a union are located at the same place in
2467  // the initializer list.
2468  if (RT->getDecl()->isUnion()) {
2469  FieldIndex = 0;
2470  if (!VerifyOnly) {
2471  FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2472  if (CurrentField && !declaresSameEntity(CurrentField, *Field)) {
2473  assert(StructuredList->getNumInits() == 1
2474  && "A union should never have more than one initializer!");
2475 
2476  Expr *ExistingInit = StructuredList->getInit(0);
2477  if (ExistingInit) {
2478  // We're about to throw away an initializer, emit warning.
2479  SemaRef.Diag(D->getFieldLoc(),
2480  diag::warn_initializer_overrides)
2481  << D->getSourceRange();
2482  SemaRef.Diag(ExistingInit->getBeginLoc(),
2483  diag::note_previous_initializer)
2484  << /*FIXME:has side effects=*/0
2485  << ExistingInit->getSourceRange();
2486  }
2487 
2488  // remove existing initializer
2489  StructuredList->resizeInits(SemaRef.Context, 0);
2490  StructuredList->setInitializedFieldInUnion(nullptr);
2491  }
2492 
2493  StructuredList->setInitializedFieldInUnion(*Field);
2494  }
2495  }
2496 
2497  // Make sure we can use this declaration.
2498  bool InvalidUse;
2499  if (VerifyOnly)
2500  InvalidUse = !SemaRef.CanUseDecl(*Field, TreatUnavailableAsInvalid);
2501  else
2502  InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
2503  if (InvalidUse) {
2504  ++Index;
2505  return true;
2506  }
2507 
2508  if (!VerifyOnly) {
2509  // Update the designator with the field declaration.
2510  D->setField(*Field);
2511 
2512  // Make sure that our non-designated initializer list has space
2513  // for a subobject corresponding to this field.
2514  if (FieldIndex >= StructuredList->getNumInits())
2515  StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
2516  }
2517 
2518  // This designator names a flexible array member.
2519  if (Field->getType()->isIncompleteArrayType()) {
2520  bool Invalid = false;
2521  if ((DesigIdx + 1) != DIE->size()) {
2522  // We can't designate an object within the flexible array
2523  // member (because GCC doesn't allow it).
2524  if (!VerifyOnly) {
2526  = DIE->getDesignator(DesigIdx + 1);
2527  SemaRef.Diag(NextD->getBeginLoc(),
2528  diag::err_designator_into_flexible_array_member)
2529  << SourceRange(NextD->getBeginLoc(), DIE->getEndLoc());
2530  SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2531  << *Field;
2532  }
2533  Invalid = true;
2534  }
2535 
2536  if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
2537  !isa<StringLiteral>(DIE->getInit())) {
2538  // The initializer is not an initializer list.
2539  if (!VerifyOnly) {
2540  SemaRef.Diag(DIE->getInit()->getBeginLoc(),
2541  diag::err_flexible_array_init_needs_braces)
2542  << DIE->getInit()->getSourceRange();
2543  SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2544  << *Field;
2545  }
2546  Invalid = true;
2547  }
2548 
2549  // Check GNU flexible array initializer.
2550  if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
2551  TopLevelObject))
2552  Invalid = true;
2553 
2554  if (Invalid) {
2555  ++Index;
2556  return true;
2557  }
2558 
2559  // Initialize the array.
2560  bool prevHadError = hadError;
2561  unsigned newStructuredIndex = FieldIndex;
2562  unsigned OldIndex = Index;
2563  IList->setInit(Index, DIE->getInit());
2564 
2565  InitializedEntity MemberEntity =
2566  InitializedEntity::InitializeMember(*Field, &Entity);
2567  CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
2568  StructuredList, newStructuredIndex);
2569 
2570  IList->setInit(OldIndex, DIE);
2571  if (hadError && !prevHadError) {
2572  ++Field;
2573  ++FieldIndex;
2574  if (NextField)
2575  *NextField = Field;
2576  StructuredIndex = FieldIndex;
2577  return true;
2578  }
2579  } else {
2580  // Recurse to check later designated subobjects.
2581  QualType FieldType = Field->getType();
2582  unsigned newStructuredIndex = FieldIndex;
2583 
2584  InitializedEntity MemberEntity =
2585  InitializedEntity::InitializeMember(*Field, &Entity);
2586  if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2587  FieldType, nullptr, nullptr, Index,
2588  StructuredList, newStructuredIndex,
2589  FinishSubobjectInit, false))
2590  return true;
2591  }
2592 
2593  // Find the position of the next field to be initialized in this
2594  // subobject.
2595  ++Field;
2596  ++FieldIndex;
2597 
2598  // If this the first designator, our caller will continue checking
2599  // the rest of this struct/class/union subobject.
2600  if (IsFirstDesignator) {
2601  if (NextField)
2602  *NextField = Field;
2603  StructuredIndex = FieldIndex;
2604  return false;
2605  }
2606 
2607  if (!FinishSubobjectInit)
2608  return false;
2609 
2610  // We've already initialized something in the union; we're done.
2611  if (RT->getDecl()->isUnion())
2612  return hadError;
2613 
2614  // Check the remaining fields within this class/struct/union subobject.
2615  bool prevHadError = hadError;
2616 
2617  auto NoBases =
2620  CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,
2621  false, Index, StructuredList, FieldIndex);
2622  return hadError && !prevHadError;
2623  }
2624 
2625  // C99 6.7.8p6:
2626  //
2627  // If a designator has the form
2628  //
2629  // [ constant-expression ]
2630  //
2631  // then the current object (defined below) shall have array
2632  // type and the expression shall be an integer constant
2633  // expression. If the array is of unknown size, any
2634  // nonnegative value is valid.
2635  //
2636  // Additionally, cope with the GNU extension that permits
2637  // designators of the form
2638  //
2639  // [ constant-expression ... constant-expression ]
2640  const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
2641  if (!AT) {
2642  if (!VerifyOnly)
2643  SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
2644  << CurrentObjectType;
2645  ++Index;
2646  return true;
2647  }
2648 
2649  Expr *IndexExpr = nullptr;
2650  llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2651  if (D->isArrayDesignator()) {
2652  IndexExpr = DIE->getArrayIndex(*D);
2653  DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
2654  DesignatedEndIndex = DesignatedStartIndex;
2655  } else {
2656  assert(D->isArrayRangeDesignator() && "Need array-range designator");
2657 
2658  DesignatedStartIndex =
2660  DesignatedEndIndex =
2661  DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
2662  IndexExpr = DIE->getArrayRangeEnd(*D);
2663 
2664  // Codegen can't handle evaluating array range designators that have side
2665  // effects, because we replicate the AST value for each initialized element.
2666  // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
2667  // elements with something that has a side effect, so codegen can emit an
2668  // "error unsupported" error instead of miscompiling the app.
2669  if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
2670  DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
2671  FullyStructuredList->sawArrayRangeDesignator();
2672  }
2673 
2674  if (isa<ConstantArrayType>(AT)) {
2675  llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
2676  DesignatedStartIndex
2677  = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
2678  DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
2679  DesignatedEndIndex
2680  = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
2681  DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2682  if (DesignatedEndIndex >= MaxElements) {
2683  if (!VerifyOnly)
2684  SemaRef.Diag(IndexExpr->getBeginLoc(),
2685  diag::err_array_designator_too_large)
2686  << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
2687  << IndexExpr->getSourceRange();
2688  ++Index;
2689  return true;
2690  }
2691  } else {
2692  unsigned DesignatedIndexBitWidth =
2694  DesignatedStartIndex =
2695  DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
2696  DesignatedEndIndex =
2697  DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
2698  DesignatedStartIndex.setIsUnsigned(true);
2699  DesignatedEndIndex.setIsUnsigned(true);
2700  }
2701 
2702  if (!VerifyOnly && StructuredList->isStringLiteralInit()) {
2703  // We're modifying a string literal init; we have to decompose the string
2704  // so we can modify the individual characters.
2705  ASTContext &Context = SemaRef.Context;
2706  Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2707 
2708  // Compute the character type
2709  QualType CharTy = AT->getElementType();
2710 
2711  // Compute the type of the integer literals.
2712  QualType PromotedCharTy = CharTy;
2713  if (CharTy->isPromotableIntegerType())
2714  PromotedCharTy = Context.getPromotedIntegerType(CharTy);
2715  unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
2716 
2717  if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
2718  // Get the length of the string.
2719  uint64_t StrLen = SL->getLength();
2720  if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2721  StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2722  StructuredList->resizeInits(Context, StrLen);
2723 
2724  // Build a literal for each character in the string, and put them into
2725  // the init list.
2726  for (unsigned i = 0, e = StrLen; i != e; ++i) {
2727  llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2728  Expr *Init = new (Context) IntegerLiteral(
2729  Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2730  if (CharTy != PromotedCharTy)
2731  Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2732  Init, nullptr, VK_RValue);
2733  StructuredList->updateInit(Context, i, Init);
2734  }
2735  } else {
2736  ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
2737  std::string Str;
2738  Context.getObjCEncodingForType(E->getEncodedType(), Str);
2739 
2740  // Get the length of the string.
2741  uint64_t StrLen = Str.size();
2742  if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2743  StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2744  StructuredList->resizeInits(Context, StrLen);
2745 
2746  // Build a literal for each character in the string, and put them into
2747  // the init list.
2748  for (unsigned i = 0, e = StrLen; i != e; ++i) {
2749  llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2750  Expr *Init = new (Context) IntegerLiteral(
2751  Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2752  if (CharTy != PromotedCharTy)
2753  Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2754  Init, nullptr, VK_RValue);
2755  StructuredList->updateInit(Context, i, Init);
2756  }
2757  }
2758  }
2759 
2760  // Make sure that our non-designated initializer list has space
2761  // for a subobject corresponding to this array element.
2762  if (!VerifyOnly &&
2763  DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
2764  StructuredList->resizeInits(SemaRef.Context,
2765  DesignatedEndIndex.getZExtValue() + 1);
2766 
2767  // Repeatedly perform subobject initializations in the range
2768  // [DesignatedStartIndex, DesignatedEndIndex].
2769 
2770  // Move to the next designator
2771  unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
2772  unsigned OldIndex = Index;
2773 
2774  InitializedEntity ElementEntity =
2775  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
2776 
2777  while (DesignatedStartIndex <= DesignatedEndIndex) {
2778  // Recurse to check later designated subobjects.
2779  QualType ElementType = AT->getElementType();
2780  Index = OldIndex;
2781 
2782  ElementEntity.setElementIndex(ElementIndex);
2783  if (CheckDesignatedInitializer(
2784  ElementEntity, IList, DIE, DesigIdx + 1, ElementType, nullptr,
2785  nullptr, Index, StructuredList, ElementIndex,
2786  FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),
2787  false))
2788  return true;
2789 
2790  // Move to the next index in the array that we'll be initializing.
2791  ++DesignatedStartIndex;
2792  ElementIndex = DesignatedStartIndex.getZExtValue();
2793  }
2794 
2795  // If this the first designator, our caller will continue checking
2796  // the rest of this array subobject.
2797  if (IsFirstDesignator) {
2798  if (NextElementIndex)
2799  *NextElementIndex = DesignatedStartIndex;
2800  StructuredIndex = ElementIndex;
2801  return false;
2802  }
2803 
2804  if (!FinishSubobjectInit)
2805  return false;
2806 
2807  // Check the remaining elements within this array subobject.
2808  bool prevHadError = hadError;
2809  CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
2810  /*SubobjectIsDesignatorContext=*/false, Index,
2811  StructuredList, ElementIndex);
2812  return hadError && !prevHadError;
2813 }
2814 
2815 // Get the structured initializer list for a subobject of type
2816 // @p CurrentObjectType.
2817 InitListExpr *
2818 InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2819  QualType CurrentObjectType,
2820  InitListExpr *StructuredList,
2821  unsigned StructuredIndex,
2822  SourceRange InitRange,
2823  bool IsFullyOverwritten) {
2824  if (VerifyOnly)
2825  return nullptr; // No structured list in verification-only mode.
2826  Expr *ExistingInit = nullptr;
2827  if (!StructuredList)
2828  ExistingInit = SyntacticToSemantic.lookup(IList);
2829  else if (StructuredIndex < StructuredList->getNumInits())
2830  ExistingInit = StructuredList->getInit(StructuredIndex);
2831 
2832  if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2833  // There might have already been initializers for subobjects of the current
2834  // object, but a subsequent initializer list will overwrite the entirety
2835  // of the current object. (See DR 253 and C99 6.7.8p21). e.g.,
2836  //
2837  // struct P { char x[6]; };
2838  // struct P l = { .x[2] = 'x', .x = { [0] = 'f' } };
2839  //
2840  // The first designated initializer is ignored, and l.x is just "f".
2841  if (!IsFullyOverwritten)
2842  return Result;
2843 
2844  if (ExistingInit) {
2845  // We are creating an initializer list that initializes the
2846  // subobjects of the current object, but there was already an
2847  // initialization that completely initialized the current
2848  // subobject, e.g., by a compound literal:
2849  //
2850  // struct X { int a, b; };
2851  // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2852  //
2853  // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2854  // designated initializer re-initializes the whole
2855  // subobject [0], overwriting previous initializers.
2856  SemaRef.Diag(InitRange.getBegin(),
2857  diag::warn_subobject_initializer_overrides)
2858  << InitRange;
2859  SemaRef.Diag(ExistingInit->getBeginLoc(), diag::note_previous_initializer)
2860  << /*FIXME:has side effects=*/0 << ExistingInit->getSourceRange();
2861  }
2862 
2864  = new (SemaRef.Context) InitListExpr(SemaRef.Context,
2865  InitRange.getBegin(), None,
2866  InitRange.getEnd());
2867 
2868  QualType ResultType = CurrentObjectType;
2869  if (!ResultType->isArrayType())
2870  ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2871  Result->setType(ResultType);
2872 
2873  // Pre-allocate storage for the structured initializer list.
2874  unsigned NumElements = 0;
2875  unsigned NumInits = 0;
2876  bool GotNumInits = false;
2877  if (!StructuredList) {
2878  NumInits = IList->getNumInits();
2879  GotNumInits = true;
2880  } else if (Index < IList->getNumInits()) {
2881  if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
2882  NumInits = SubList->getNumInits();
2883  GotNumInits = true;
2884  }
2885  }
2886 
2887  if (const ArrayType *AType
2888  = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2889  if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2890  NumElements = CAType->getSize().getZExtValue();
2891  // Simple heuristic so that we don't allocate a very large
2892  // initializer with many empty entries at the end.
2893  if (GotNumInits && NumElements > NumInits)
2894  NumElements = 0;
2895  }
2896  } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
2897  NumElements = VType->getNumElements();
2898  else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
2899  RecordDecl *RDecl = RType->getDecl();
2900  if (RDecl->isUnion())
2901  NumElements = 1;
2902  else
2903  NumElements = std::distance(RDecl->field_begin(), RDecl->field_end());
2904  }
2905 
2906  Result->reserveInits(SemaRef.Context, NumElements);
2907 
2908  // Link this new initializer list into the structured initializer
2909  // lists.
2910  if (StructuredList)
2911  StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
2912  else {
2913  Result->setSyntacticForm(IList);
2914  SyntacticToSemantic[IList] = Result;
2915  }
2916 
2917  return Result;
2918 }
2919 
2920 /// Update the initializer at index @p StructuredIndex within the
2921 /// structured initializer list to the value @p expr.
2922 void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2923  unsigned &StructuredIndex,
2924  Expr *expr) {
2925  // No structured initializer list to update
2926  if (!StructuredList)
2927  return;
2928 
2929  if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2930  StructuredIndex, expr)) {
2931  // This initializer overwrites a previous initializer. Warn.
2932  // We need to check on source range validity because the previous
2933  // initializer does not have to be an explicit initializer.
2934  // struct P { int a, b; };
2935  // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2936  // There is an overwrite taking place because the first braced initializer
2937  // list "{ .a = 2 }' already provides value for .p.b (which is zero).
2938  if (PrevInit->getSourceRange().isValid()) {
2939  SemaRef.Diag(expr->getBeginLoc(), diag::warn_initializer_overrides)
2940  << expr->getSourceRange();
2941 
2942  SemaRef.Diag(PrevInit->getBeginLoc(), diag::note_previous_initializer)
2943  << /*FIXME:has side effects=*/0 << PrevInit->getSourceRange();
2944  }
2945  }
2946 
2947  ++StructuredIndex;
2948 }
2949 
2950 /// Check that the given Index expression is a valid array designator
2951 /// value. This is essentially just a wrapper around
2952 /// VerifyIntegerConstantExpression that also checks for negative values
2953 /// and produces a reasonable diagnostic if there is a
2954 /// failure. Returns the index expression, possibly with an implicit cast
2955 /// added, on success. If everything went okay, Value will receive the
2956 /// value of the constant expression.
2957 static ExprResult
2958 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
2959  SourceLocation Loc = Index->getBeginLoc();
2960 
2961  // Make sure this is an integer constant expression.
2963  if (Result.isInvalid())
2964  return Result;
2965 
2966  if (Value.isSigned() && Value.isNegative())
2967  return S.Diag(Loc, diag::err_array_designator_negative)
2968  << Value.toString(10) << Index->getSourceRange();
2969 
2970  Value.setIsUnsigned(true);
2971  return Result;
2972 }
2973 
2975  SourceLocation Loc,
2976  bool GNUSyntax,
2977  ExprResult Init) {
2978  typedef DesignatedInitExpr::Designator ASTDesignator;
2979 
2980  bool Invalid = false;
2981  SmallVector<ASTDesignator, 32> Designators;
2982  SmallVector<Expr *, 32> InitExpressions;
2983 
2984  // Build designators and check array designator expressions.
2985  for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2986  const Designator &D = Desig.getDesignator(Idx);
2987  switch (D.getKind()) {
2989  Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
2990  D.getFieldLoc()));
2991  break;
2992 
2994  Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2995  llvm::APSInt IndexValue;
2996  if (!Index->isTypeDependent() && !Index->isValueDependent())
2997  Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get();
2998  if (!Index)
2999  Invalid = true;
3000  else {
3001  Designators.push_back(ASTDesignator(InitExpressions.size(),
3002  D.getLBracketLoc(),
3003  D.getRBracketLoc()));
3004  InitExpressions.push_back(Index);
3005  }
3006  break;
3007  }
3008 
3010  Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
3011  Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
3012  llvm::APSInt StartValue;
3013  llvm::APSInt EndValue;
3014  bool StartDependent = StartIndex->isTypeDependent() ||
3015  StartIndex->isValueDependent();
3016  bool EndDependent = EndIndex->isTypeDependent() ||
3017  EndIndex->isValueDependent();
3018  if (!StartDependent)
3019  StartIndex =
3020  CheckArrayDesignatorExpr(*this, StartIndex, StartValue).get();
3021  if (!EndDependent)
3022  EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).get();
3023 
3024  if (!StartIndex || !EndIndex)
3025  Invalid = true;
3026  else {
3027  // Make sure we're comparing values with the same bit width.
3028  if (StartDependent || EndDependent) {
3029  // Nothing to compute.
3030  } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
3031  EndValue = EndValue.extend(StartValue.getBitWidth());
3032  else if (StartValue.getBitWidth() < EndValue.getBitWidth())
3033  StartValue = StartValue.extend(EndValue.getBitWidth());
3034 
3035  if (!StartDependent && !EndDependent && EndValue < StartValue) {
3036  Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
3037  << StartValue.toString(10) << EndValue.toString(10)
3038  << StartIndex->getSourceRange() << EndIndex->getSourceRange();
3039  Invalid = true;
3040  } else {
3041  Designators.push_back(ASTDesignator(InitExpressions.size(),
3042  D.getLBracketLoc(),
3043  D.getEllipsisLoc(),
3044  D.getRBracketLoc()));
3045  InitExpressions.push_back(StartIndex);
3046  InitExpressions.push_back(EndIndex);
3047  }
3048  }
3049  break;
3050  }
3051  }
3052  }
3053 
3054  if (Invalid || Init.isInvalid())
3055  return ExprError();
3056 
3057  // Clear out the expressions within the designation.
3058  Desig.ClearExprs(*this);
3059 
3060  DesignatedInitExpr *DIE
3061  = DesignatedInitExpr::Create(Context,
3062  Designators,
3063  InitExpressions, Loc, GNUSyntax,
3064  Init.getAs<Expr>());
3065 
3066  if (!getLangOpts().C99)
3067  Diag(DIE->getBeginLoc(), diag::ext_designated_init)
3068  << DIE->getSourceRange();
3069 
3070  return DIE;
3071 }
3072 
3073 //===----------------------------------------------------------------------===//
3074 // Initialization entity
3075 //===----------------------------------------------------------------------===//
3076 
3077 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
3078  const InitializedEntity &Parent)
3079  : Parent(&Parent), Index(Index)
3080 {
3081  if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
3082  Kind = EK_ArrayElement;
3083  Type = AT->getElementType();
3084  } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
3085  Kind = EK_VectorElement;
3086  Type = VT->getElementType();
3087  } else {
3088  const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
3089  assert(CT && "Unexpected type");
3090  Kind = EK_ComplexElement;
3091  Type = CT->getElementType();
3092  }
3093 }
3094 
3097  const CXXBaseSpecifier *Base,
3098  bool IsInheritedVirtualBase,
3099  const InitializedEntity *Parent) {
3101  Result.Kind = EK_Base;
3102  Result.Parent = Parent;
3103  Result.Base = reinterpret_cast<uintptr_t>(Base);
3104  if (IsInheritedVirtualBase)
3105  Result.Base |= 0x01;
3106 
3107  Result.Type = Base->getType();
3108  return Result;
3109 }
3110 
3112  switch (getKind()) {
3113  case EK_Parameter:
3114  case EK_Parameter_CF_Audited: {
3115  ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
3116  return (D ? D->getDeclName() : DeclarationName());
3117  }
3118 
3119  case EK_Variable:
3120  case EK_Member:
3121  case EK_Binding:
3122  return Variable.VariableOrMember->getDeclName();
3123 
3124  case EK_LambdaCapture:
3125  return DeclarationName(Capture.VarID);
3126 
3127  case EK_Result:
3128  case EK_StmtExprResult:
3129  case EK_Exception:
3130  case EK_New:
3131  case EK_Temporary:
3132  case EK_Base:
3133  case EK_Delegating:
3134  case EK_ArrayElement:
3135  case EK_VectorElement:
3136  case EK_ComplexElement:
3137  case EK_BlockElement:
3138  case EK_LambdaToBlockConversionBlockElement:
3139  case EK_CompoundLiteralInit:
3140  case EK_RelatedResult:
3141  return DeclarationName();
3142  }
3143 
3144  llvm_unreachable("Invalid EntityKind!");
3145 }
3146 
3148  switch (getKind()) {
3149  case EK_Variable:
3150  case EK_Member:
3151  case EK_Binding:
3152  return Variable.VariableOrMember;
3153 
3154  case EK_Parameter:
3155  case EK_Parameter_CF_Audited:
3156  return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
3157 
3158  case EK_Result:
3159  case EK_StmtExprResult:
3160  case EK_Exception:
3161  case EK_New:
3162  case EK_Temporary:
3163  case EK_Base:
3164  case EK_Delegating:
3165  case EK_ArrayElement:
3166  case EK_VectorElement:
3167  case EK_ComplexElement:
3168  case EK_BlockElement:
3169  case EK_LambdaToBlockConversionBlockElement:
3170  case EK_LambdaCapture:
3171  case EK_CompoundLiteralInit:
3172  case EK_RelatedResult:
3173  return nullptr;
3174  }
3175 
3176  llvm_unreachable("Invalid EntityKind!");
3177 }
3178 
3180  switch (getKind()) {
3181  case EK_Result:
3182  case EK_Exception:
3183  return LocAndNRVO.NRVO;
3184 
3185  case EK_StmtExprResult:
3186  case EK_Variable:
3187  case EK_Parameter:
3188  case EK_Parameter_CF_Audited:
3189  case EK_Member:
3190  case EK_Binding:
3191  case EK_New:
3192  case EK_Temporary:
3193  case EK_CompoundLiteralInit:
3194  case EK_Base:
3195  case EK_Delegating:
3196  case EK_ArrayElement:
3197  case EK_VectorElement:
3198  case EK_ComplexElement:
3199  case EK_BlockElement:
3200  case EK_LambdaToBlockConversionBlockElement:
3201  case EK_LambdaCapture:
3202  case EK_RelatedResult:
3203  break;
3204  }
3205 
3206  return false;
3207 }
3208 
3209 unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
3210  assert(getParent() != this);
3211  unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
3212  for (unsigned I = 0; I != Depth; ++I)
3213  OS << "`-";
3214 
3215  switch (getKind()) {
3216  case EK_Variable: OS << "Variable"; break;
3217  case EK_Parameter: OS << "Parameter"; break;
3218  case EK_Parameter_CF_Audited: OS << "CF audited function Parameter";
3219  break;
3220  case EK_Result: OS << "Result"; break;
3221  case EK_StmtExprResult: OS << "StmtExprResult"; break;
3222  case EK_Exception: OS << "Exception"; break;
3223  case EK_Member: OS << "Member"; break;
3224  case EK_Binding: OS << "Binding"; break;
3225  case EK_New: OS << "New"; break;
3226  case EK_Temporary: OS << "Temporary"; break;
3227  case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
3228  case EK_RelatedResult: OS << "RelatedResult"; break;
3229  case EK_Base: OS << "Base"; break;
3230  case EK_Delegating: OS << "Delegating"; break;
3231  case EK_ArrayElement: OS << "ArrayElement " << Index; break;
3232  case EK_VectorElement: OS << "VectorElement " << Index; break;
3233  case EK_ComplexElement: OS << "ComplexElement " << Index; break;
3234  case EK_BlockElement: OS << "Block"; break;
3235  case EK_LambdaToBlockConversionBlockElement:
3236  OS << "Block (lambda)";
3237  break;
3238  case EK_LambdaCapture:
3239  OS << "LambdaCapture ";
3240  OS << DeclarationName(Capture.VarID);
3241  break;
3242  }
3243 
3244  if (auto *D = getDecl()) {
3245  OS << " ";
3246  D->printQualifiedName(OS);
3247  }
3248 
3249  OS << " '" << getType().getAsString() << "'\n";
3250 
3251  return Depth + 1;
3252 }
3253 
3254 LLVM_DUMP_METHOD void InitializedEntity::dump() const {
3255  dumpImpl(llvm::errs());
3256 }
3257 
3258 //===----------------------------------------------------------------------===//
3259 // Initialization sequence
3260 //===----------------------------------------------------------------------===//
3261 
3263  switch (Kind) {
3264  case SK_ResolveAddressOfOverloadedFunction:
3265  case SK_CastDerivedToBaseRValue:
3266  case SK_CastDerivedToBaseXValue:
3267  case SK_CastDerivedToBaseLValue:
3268  case SK_BindReference:
3269  case SK_BindReferenceToTemporary:
3270  case SK_FinalCopy:
3271  case SK_ExtraneousCopyToTemporary:
3272  case SK_UserConversion:
3273  case SK_QualificationConversionRValue:
3274  case SK_QualificationConversionXValue:
3275  case SK_QualificationConversionLValue:
3276  case SK_AtomicConversion:
3277  case SK_LValueToRValue:
3278  case SK_ListInitialization:
3279  case SK_UnwrapInitList:
3280  case SK_RewrapInitList:
3281  case SK_ConstructorInitialization:
3282  case SK_ConstructorInitializationFromList:
3283  case SK_ZeroInitialization:
3284  case SK_CAssignment:
3285  case SK_StringInit:
3286  case SK_ObjCObjectConversion:
3287  case SK_ArrayLoopIndex:
3288  case SK_ArrayLoopInit:
3289  case SK_ArrayInit:
3290  case SK_GNUArrayInit:
3291  case SK_ParenthesizedArrayInit:
3292  case SK_PassByIndirectCopyRestore:
3293  case SK_PassByIndirectRestore:
3294  case SK_ProduceObjCObject:
3295  case SK_StdInitializerList:
3296  case SK_StdInitializerListConstructorCall:
3297  case SK_OCLSamplerInit:
3298  case SK_OCLZeroOpaqueType:
3299  break;
3300 
3301  case SK_ConversionSequence:
3302  case SK_ConversionSequenceNoNarrowing:
3303  delete ICS;
3304  }
3305 }
3306 
3308  // There can be some lvalue adjustments after the SK_BindReference step.
3309  for (auto I = Steps.rbegin(); I != Steps.rend(); ++I) {
3310  if (I->Kind == SK_BindReference)
3311  return true;
3312  if (I->Kind == SK_BindReferenceToTemporary)
3313  return false;
3314  }
3315  return false;
3316 }
3317 
3319  if (!Failed())
3320  return false;
3321 
3322  switch (getFailureKind()) {
3323  case FK_TooManyInitsForReference:
3324  case FK_ParenthesizedListInitForReference:
3325  case FK_ArrayNeedsInitList:
3326  case FK_ArrayNeedsInitListOrStringLiteral:
3327  case FK_ArrayNeedsInitListOrWideStringLiteral:
3328  case FK_NarrowStringIntoWideCharArray:
3329  case FK_WideStringIntoCharArray:
3330  case FK_IncompatWideStringIntoWideChar:
3331  case FK_PlainStringIntoUTF8Char:
3332  case FK_UTF8StringIntoPlainChar:
3333  case FK_AddressOfOverloadFailed: // FIXME: Could do better
3334  case FK_NonConstLValueReferenceBindingToTemporary:
3335  case FK_NonConstLValueReferenceBindingToBitfield:
3336  case FK_NonConstLValueReferenceBindingToVectorElement:
3337  case FK_NonConstLValueReferenceBindingToUnrelated:
3338  case FK_RValueReferenceBindingToLValue:
3339  case FK_ReferenceInitDropsQualifiers:
3340  case FK_ReferenceInitFailed:
3341  case FK_ConversionFailed:
3342  case FK_ConversionFromPropertyFailed:
3343  case FK_TooManyInitsForScalar:
3344  case FK_ParenthesizedListInitForScalar:
3345  case FK_ReferenceBindingToInitList:
3346  case FK_InitListBadDestinationType:
3347  case FK_DefaultInitOfConst:
3348  case FK_Incomplete:
3349  case FK_ArrayTypeMismatch:
3350  case FK_NonConstantArrayInit:
3351  case FK_ListInitializationFailed:
3352  case FK_VariableLengthArrayHasInitializer:
3353  case FK_PlaceholderType:
3354  case FK_ExplicitConstructor:
3355  case FK_AddressOfUnaddressableFunction:
3356  return false;
3357 
3358  case FK_ReferenceInitOverloadFailed:
3359  case FK_UserConversionOverloadFailed:
3360  case FK_ConstructorOverloadFailed:
3361  case FK_ListConstructorOverloadFailed:
3362  return FailedOverloadResult == OR_Ambiguous;
3363  }
3364 
3365  llvm_unreachable("Invalid EntityKind!");
3366 }
3367 
3369  return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
3370 }
3371 
3372 void
3375  DeclAccessPair Found,
3376  bool HadMultipleCandidates) {
3377  Step S;
3378  S.Kind = SK_ResolveAddressOfOverloadedFunction;
3379  S.Type = Function->getType();
3380  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3381  S.Function.Function = Function;
3382  S.Function.FoundDecl = Found;
3383  Steps.push_back(S);
3384 }
3385 
3387  ExprValueKind VK) {
3388  Step S;
3389  switch (VK) {
3390  case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
3391  case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
3392  case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
3393  }
3394  S.Type = BaseType;
3395  Steps.push_back(S);
3396 }
3397 
3399  bool BindingTemporary) {
3400  Step S;
3401  S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
3402  S.Type = T;
3403  Steps.push_back(S);
3404 }
3405 
3407  Step S;
3408  S.Kind = SK_FinalCopy;
3409  S.Type = T;
3410  Steps.push_back(S);
3411 }
3412 
3414  Step S;
3415  S.Kind = SK_ExtraneousCopyToTemporary;
3416  S.Type = T;
3417  Steps.push_back(S);
3418 }
3419 
3420 void
3422  DeclAccessPair FoundDecl,
3423  QualType T,
3424  bool HadMultipleCandidates) {
3425  Step S;
3426  S.Kind = SK_UserConversion;
3427  S.Type = T;
3428  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3429  S.Function.Function = Function;
3430  S.Function.FoundDecl = FoundDecl;
3431  Steps.push_back(S);
3432 }
3433 
3435  ExprValueKind VK) {
3436  Step S;
3437  S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
3438  switch (VK) {
3439  case VK_RValue:
3440  S.Kind = SK_QualificationConversionRValue;
3441  break;
3442  case VK_XValue:
3443  S.Kind = SK_QualificationConversionXValue;
3444  break;
3445  case VK_LValue:
3446  S.Kind = SK_QualificationConversionLValue;
3447  break;
3448  }
3449  S.Type = Ty;
3450  Steps.push_back(S);
3451 }
3452 
3454  Step S;
3455  S.Kind = SK_AtomicConversion;
3456  S.Type = Ty;
3457  Steps.push_back(S);
3458 }
3459 
3461  assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
3462 
3463  Step S;
3464  S.Kind = SK_LValueToRValue;
3465  S.Type = Ty;
3466  Steps.push_back(S);
3467 }
3468 
3470  const ImplicitConversionSequence &ICS, QualType T,
3471  bool TopLevelOfInitList) {
3472  Step S;
3473  S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing
3474  : SK_ConversionSequence;
3475  S.Type = T;
3476  S.ICS = new ImplicitConversionSequence(ICS);
3477  Steps.push_back(S);
3478 }
3479 
3481  Step S;
3482  S.Kind = SK_ListInitialization;
3483  S.Type = T;
3484  Steps.push_back(S);
3485 }
3486 
3488  DeclAccessPair FoundDecl, CXXConstructorDecl *Constructor, QualType T,
3489  bool HadMultipleCandidates, bool FromInitList, bool AsInitList) {
3490  Step S;
3491  S.Kind = FromInitList ? AsInitList ? SK_StdInitializerListConstructorCall
3492  : SK_ConstructorInitializationFromList
3493  : SK_ConstructorInitialization;
3494  S.Type = T;
3495  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3496  S.Function.Function = Constructor;
3497  S.Function.FoundDecl = FoundDecl;
3498  Steps.push_back(S);
3499 }
3500 
3502  Step S;
3503  S.Kind = SK_ZeroInitialization;
3504  S.Type = T;
3505  Steps.push_back(S);
3506 }
3507 
3509  Step S;
3510  S.Kind = SK_CAssignment;
3511  S.Type = T;
3512  Steps.push_back(S);
3513 }
3514 
3516  Step S;
3517  S.Kind = SK_StringInit;
3518  S.Type = T;
3519  Steps.push_back(S);
3520 }
3521 
3523  Step S;
3524  S.Kind = SK_ObjCObjectConversion;
3525  S.Type = T;
3526  Steps.push_back(S);
3527 }
3528 
3530  Step S;
3531  S.Kind = IsGNUExtension ? SK_GNUArrayInit : SK_ArrayInit;
3532  S.Type = T;
3533  Steps.push_back(S);
3534 }
3535 
3537  Step S;
3538  S.Kind = SK_ArrayLoopIndex;
3539  S.Type = EltT;
3540  Steps.insert(Steps.begin(), S);
3541 
3542  S.Kind = SK_ArrayLoopInit;
3543  S.Type = T;
3544  Steps.push_back(S);
3545 }
3546 
3548  Step S;
3549  S.Kind = SK_ParenthesizedArrayInit;
3550  S.Type = T;
3551  Steps.push_back(S);
3552 }
3553 
3555  bool shouldCopy) {
3556  Step s;
3557  s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
3558  : SK_PassByIndirectRestore);
3559  s.Type = type;
3560  Steps.push_back(s);
3561 }
3562 
3564  Step S;
3565  S.Kind = SK_ProduceObjCObject;
3566  S.Type = T;
3567  Steps.push_back(S);
3568 }
3569 
3571  Step S;
3572  S.Kind = SK_StdInitializerList;
3573  S.Type = T;
3574  Steps.push_back(S);
3575 }
3576 
3578  Step S;
3579  S.Kind = SK_OCLSamplerInit;
3580  S.Type = T;
3581  Steps.push_back(S);
3582 }
3583 
3585  Step S;
3586  S.Kind = SK_OCLZeroOpaqueType;
3587  S.Type = T;
3588  Steps.push_back(S);
3589 }
3590 
3592  InitListExpr *Syntactic) {
3593  assert(Syntactic->getNumInits() == 1 &&
3594  "Can only rewrap trivial init lists.");
3595  Step S;
3596  S.Kind = SK_UnwrapInitList;
3597  S.Type = Syntactic->getInit(0)->getType();
3598  Steps.insert(Steps.begin(), S);
3599 
3600  S.Kind = SK_RewrapInitList;
3601  S.Type = T;
3602  S.WrappingSyntacticList = Syntactic;
3603  Steps.push_back(S);
3604 }
3605 
3608  setSequenceKind(FailedSequence);
3609  this->Failure = Failure;
3610  this->FailedOverloadResult = Result;
3611 }
3612 
3613 //===----------------------------------------------------------------------===//
3614 // Attempt initialization
3615 //===----------------------------------------------------------------------===//
3616 
3617 /// Tries to add a zero initializer. Returns true if that worked.
3618 static bool
3620  const InitializedEntity &Entity) {
3621  if (Entity.getKind() != InitializedEntity::EK_Variable)
3622  return false;
3623 
3624  VarDecl *VD = cast<VarDecl>(Entity.getDecl());
3625  if (VD->getInit() || VD->getEndLoc().isMacroID())
3626  return false;
3627 
3628  QualType VariableTy = VD->getType().getCanonicalType();
3630  std::string Init = S.getFixItZeroInitializerForType(VariableTy, Loc);
3631  if (!Init.empty()) {
3632  Sequence.AddZeroInitializationStep(Entity.getType());
3633  Sequence.SetZeroInitializationFixit(Init, Loc);
3634  return true;
3635  }
3636  return false;
3637 }
3638 
3640  InitializationSequence &Sequence,
3641  const InitializedEntity &Entity) {
3642  if (!S.getLangOpts().ObjCAutoRefCount) return;
3643 
3644  /// When initializing a parameter, produce the value if it's marked
3645  /// __attribute__((ns_consumed)).
3646  if (Entity.isParameterKind()) {
3647  if (!Entity.isParameterConsumed())
3648  return;
3649 
3650  assert(Entity.getType()->isObjCRetainableType() &&
3651  "consuming an object of unretainable type?");
3652  Sequence.AddProduceObjCObjectStep(Entity.getType());
3653 
3654  /// When initializing a return value, if the return type is a
3655  /// retainable type, then returns need to immediately retain the
3656  /// object. If an autorelease is required, it will be done at the
3657  /// last instant.
3658  } else if (Entity.getKind() == InitializedEntity::EK_Result ||
3660  if (!Entity.getType()->isObjCRetainableType())
3661  return;
3662 
3663  Sequence.AddProduceObjCObjectStep(Entity.getType());
3664  }
3665 }
3666 
3667 static void TryListInitialization(Sema &S,
3668  const InitializedEntity &Entity,
3669  const InitializationKind &Kind,
3670  InitListExpr *InitList,
3671  InitializationSequence &Sequence,
3672  bool TreatUnavailableAsInvalid);
3673 
3674 /// When initializing from init list via constructor, handle
3675 /// initialization of an object of type std::initializer_list<T>.
3676 ///
3677 /// \return true if we have handled initialization of an object of type
3678 /// std::initializer_list<T>, false otherwise.
3680  InitListExpr *List,
3681  QualType DestType,
3682  InitializationSequence &Sequence,
3683  bool TreatUnavailableAsInvalid) {
3684  QualType E;
3685  if (!S.isStdInitializerList(DestType, &E))
3686  return false;
3687 
3688  if (!S.isCompleteType(List->getExprLoc(), E)) {
3689  Sequence.setIncompleteTypeFailure(E);
3690  return true;
3691  }
3692 
3693  // Try initializing a temporary array from the init list.
3695  E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
3696  List->getNumInits()),
3698  InitializedEntity HiddenArray =
3701  List->getExprLoc(), List->getBeginLoc(), List->getEndLoc());
3702  TryListInitialization(S, HiddenArray, Kind, List, Sequence,
3703  TreatUnavailableAsInvalid);
3704  if (Sequence)
3705  Sequence.AddStdInitializerListConstructionStep(DestType);
3706  return true;
3707 }
3708 
3709 /// Determine if the constructor has the signature of a copy or move
3710 /// constructor for the type T of the class in which it was found. That is,
3711 /// determine if its first parameter is of type T or reference to (possibly
3712 /// cv-qualified) T.
3714  const ConstructorInfo &Info) {
3715  if (Info.Constructor->getNumParams() == 0)
3716  return false;
3717 
3718  QualType ParmT =
3720  QualType ClassT =
3721  Ctx.getRecordType(cast<CXXRecordDecl>(Info.FoundDecl->getDeclContext()));
3722 
3723  return Ctx.hasSameUnqualifiedType(ParmT, ClassT);
3724 }
3725 
3726 static OverloadingResult
3728  MultiExprArg Args,
3729  OverloadCandidateSet &CandidateSet,
3730  QualType DestType,
3733  bool CopyInitializing, bool AllowExplicit,
3734  bool OnlyListConstructors, bool IsListInit,
3735  bool SecondStepOfCopyInit = false) {
3737 
3738  for (NamedDecl *D : Ctors) {
3739  auto Info = getConstructorInfo(D);
3740  if (!Info.Constructor || Info.Constructor->isInvalidDecl())
3741  continue;
3742 
3743  if (!AllowExplicit && Info.Constructor->isExplicit())
3744  continue;
3745 
3746  if (OnlyListConstructors && !S.isInitListConstructor(Info.Constructor))
3747  continue;
3748 
3749  // C++11 [over.best.ics]p4:
3750  // ... and the constructor or user-defined conversion function is a
3751  // candidate by
3752  // - 13.3.1.3, when the argument is the temporary in the second step
3753  // of a class copy-initialization, or
3754  // - 13.3.1.4, 13.3.1.5, or 13.3.1.6 (in all cases), [not handled here]
3755  // - the second phase of 13.3.1.7 when the initializer list has exactly
3756  // one element that is itself an initializer list, and the target is
3757  // the first parameter of a constructor of class X, and the conversion
3758  // is to X or reference to (possibly cv-qualified X),
3759  // user-defined conversion sequences are not considered.
3760  bool SuppressUserConversions =
3761  SecondStepOfCopyInit ||
3762  (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
3763  hasCopyOrMoveCtorParam(S.Context, Info));
3764 
3765  if (Info.ConstructorTmpl)
3766  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
3767  /*ExplicitArgs*/ nullptr, Args,
3768  CandidateSet, SuppressUserConversions);
3769  else {
3770  // C++ [over.match.copy]p1:
3771  // - When initializing a temporary to be bound to the first parameter
3772  // of a constructor [for type T] that takes a reference to possibly
3773  // cv-qualified T as its first argument, called with a single
3774  // argument in the context of direct-initialization, explicit
3775  // conversion functions are also considered.
3776  // FIXME: What if a constructor template instantiates to such a signature?
3777  bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
3778  Args.size() == 1 &&
3780  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, Args,
3781  CandidateSet, SuppressUserConversions,
3782  /*PartialOverloading=*/false,
3783  /*AllowExplicit=*/AllowExplicitConv);
3784  }
3785  }
3786 
3787  // FIXME: Work around a bug in C++17 guaranteed copy elision.
3788  //
3789  // When initializing an object of class type T by constructor
3790  // ([over.match.ctor]) or by list-initialization ([over.match.list])
3791  // from a single expression of class type U, conversion functions of
3792  // U that convert to the non-reference type cv T are candidates.
3793  // Explicit conversion functions are only candidates during
3794  // direct-initialization.
3795  //
3796  // Note: SecondStepOfCopyInit is only ever true in this case when
3797  // evaluating whether to produce a C++98 compatibility warning.
3798  if (S.getLangOpts().CPlusPlus17 && Args.size() == 1 &&
3799  !SecondStepOfCopyInit) {
3800  Expr *Initializer = Args[0];
3801  auto *SourceRD = Initializer->getType()->getAsCXXRecordDecl();
3802  if (SourceRD && S.isCompleteType(DeclLoc, Initializer->getType())) {
3803  const auto &Conversions = SourceRD->getVisibleConversionFunctions();
3804  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3805  NamedDecl *D = *I;
3806  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3807  D = D->getUnderlyingDecl();
3808 
3809  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
3810  CXXConversionDecl *Conv;
3811  if (ConvTemplate)
3812  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3813  else
3814  Conv = cast<CXXConversionDecl>(D);
3815 
3816  if ((AllowExplicit && !CopyInitializing) || !Conv->isExplicit()) {
3817  if (ConvTemplate)
3818  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
3819  ActingDC, Initializer, DestType,
3820  CandidateSet, AllowExplicit,
3821  /*AllowResultConversion*/false);
3822  else
3823  S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Initializer,
3824  DestType, CandidateSet, AllowExplicit,
3825  /*AllowResultConversion*/false);
3826  }
3827  }
3828  }
3829  }
3830 
3831  // Perform overload resolution and return the result.
3832  return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3833 }
3834 
3835 /// Attempt initialization by constructor (C++ [dcl.init]), which
3836 /// enumerates the constructors of the initialized entity and performs overload
3837 /// resolution to select the best.
3838 /// \param DestType The destination class type.
3839 /// \param DestArrayType The destination type, which is either DestType or
3840 /// a (possibly multidimensional) array of DestType.
3841 /// \param IsListInit Is this list-initialization?
3842 /// \param IsInitListCopy Is this non-list-initialization resulting from a
3843 /// list-initialization from {x} where x is the same
3844 /// type as the entity?
3846  const InitializedEntity &Entity,
3847  const InitializationKind &Kind,
3848  MultiExprArg Args, QualType DestType,
3849  QualType DestArrayType,
3850  InitializationSequence &Sequence,
3851  bool IsListInit = false,
3852  bool IsInitListCopy = false) {
3853  assert(((!IsListInit && !IsInitListCopy) ||
3854  (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
3855  "IsListInit/IsInitListCopy must come with a single initializer list "
3856  "argument.");
3857  InitListExpr *ILE =
3858  (IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) : nullptr;
3859  MultiExprArg UnwrappedArgs =
3860  ILE ? MultiExprArg(ILE->getInits(), ILE->getNumInits()) : Args;
3861 
3862  // The type we're constructing needs to be complete.
3863  if (!S.isCompleteType(Kind.getLocation(), DestType)) {
3864  Sequence.setIncompleteTypeFailure(DestType);
3865  return;
3866  }
3867 
3868  // C++17 [dcl.init]p17:
3869  // - If the initializer expression is a prvalue and the cv-unqualified
3870  // version of the source type is the same class as the class of the
3871  // destination, the initializer expression is used to initialize the
3872  // destination object.
3873  // Per DR (no number yet), this does not apply when initializing a base
3874  // class or delegating to another constructor from a mem-initializer.
3875  // ObjC++: Lambda captured by the block in the lambda to block conversion
3876  // should avoid copy elision.
3877  if (S.getLangOpts().CPlusPlus17 &&
3878  Entity.getKind() != InitializedEntity::EK_Base &&
3880  Entity.getKind() !=
3882  UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isRValue() &&
3883  S.Context.hasSameUnqualifiedType(UnwrappedArgs[0]->getType(), DestType)) {
3884  // Convert qualifications if necessary.
3885  Sequence.AddQualificationConversionStep(DestType, VK_RValue);
3886  if (ILE)
3887  Sequence.RewrapReferenceInitList(DestType, ILE);
3888  return;
3889  }
3890 
3891  const RecordType *DestRecordType = DestType->getAs<RecordType>();
3892  assert(DestRecordType && "Constructor initialization requires record type");
3893  CXXRecordDecl *DestRecordDecl
3894  = cast<CXXRecordDecl>(DestRecordType->getDecl());
3895 
3896  // Build the candidate set directly in the initialization sequence
3897  // structure, so that it will persist if we fail.
3898  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3899 
3900  // Determine whether we are allowed to call explicit constructors or
3901  // explicit conversion operators.
3902  bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
3903  bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
3904 
3905  // - Otherwise, if T is a class type, constructors are considered. The
3906  // applicable constructors are enumerated, and the best one is chosen
3907  // through overload resolution.
3908  DeclContext::lookup_result Ctors = S.LookupConstructors(DestRecordDecl);
3909 
3912  bool AsInitializerList = false;
3913 
3914  // C++11 [over.match.list]p1, per DR1467:
3915  // When objects of non-aggregate type T are list-initialized, such that
3916  // 8.5.4 [dcl.init.list] specifies that overload resolution is performed
3917  // according to the rules in this section, overload resolution selects
3918  // the constructor in two phases:
3919  //
3920  // - Initially, the candidate functions are the initializer-list
3921  // constructors of the class T and the argument list consists of the
3922  // initializer list as a single argument.
3923  if (IsListInit) {
3924  AsInitializerList = true;
3925 
3926  // If the initializer list has no elements and T has a default constructor,
3927  // the first phase is omitted.
3928  if (!(UnwrappedArgs.empty() && DestRecordDecl->hasDefaultConstructor()))
3929  Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3930  CandidateSet, DestType, Ctors, Best,
3931  CopyInitialization, AllowExplicit,
3932  /*OnlyListConstructor=*/true,
3933  IsListInit);
3934  }
3935 
3936  // C++11 [over.match.list]p1:
3937  // - If no viable initializer-list constructor is found, overload resolution
3938  // is performed again, where the candidate functions are all the
3939  // constructors of the class T and the argument list consists of the
3940  // elements of the initializer list.
3941  if (Result == OR_No_Viable_Function) {
3942  AsInitializerList = false;
3943  Result = ResolveConstructorOverload(S, Kind.getLocation(), UnwrappedArgs,
3944  CandidateSet, DestType, Ctors, Best,
3945  CopyInitialization, AllowExplicit,
3946  /*OnlyListConstructors=*/false,
3947  IsListInit);
3948  }
3949  if (Result) {
3950  Sequence.SetOverloadFailure(IsListInit ?
3953  Result);
3954  return;
3955  }
3956 
3957  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3958 
3959  // In C++17, ResolveConstructorOverload can select a conversion function
3960  // instead of a constructor.
3961  if (auto *CD = dyn_cast<CXXConversionDecl>(Best->Function)) {
3962  // Add the user-defined conversion step that calls the conversion function.
3963  QualType ConvType = CD->getConversionType();
3964  assert(S.Context.hasSameUnqualifiedType(ConvType, DestType) &&
3965  "should not have selected this conversion function");
3966  Sequence.AddUserConversionStep(CD, Best->FoundDecl, ConvType,
3967  HadMultipleCandidates);
3968  if (!S.Context.hasSameType(ConvType, DestType))
3969  Sequence.AddQualificationConversionStep(DestType, VK_RValue);
3970  if (IsListInit)
3971  Sequence.RewrapReferenceInitList(Entity.getType(), ILE);
3972  return;
3973  }
3974 
3975  // C++11 [dcl.init]p6:
3976  // If a program calls for the default initialization of an object
3977  // of a const-qualified type T, T shall be a class type with a
3978  // user-provided default constructor.
3979  // C++ core issue 253 proposal:
3980  // If the implicit default constructor initializes all subobjects, no
3981  // initializer should be required.
3982  // The 253 proposal is for example needed to process libstdc++ headers in 5.x.
3983  CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3984  if (Kind.getKind() == InitializationKind::IK_Default &&
3985  Entity.getType().isConstQualified()) {
3986  if (!CtorDecl->getParent()->allowConstDefaultInit()) {
3987  if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
3989  return;
3990  }
3991  }
3992 
3993  // C++11 [over.match.list]p1:
3994  // In copy-list-initialization, if an explicit constructor is chosen, the
3995  // initializer is ill-formed.
3996  if (IsListInit && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3998  return;
3999  }
4000 
4001  // Add the constructor initialization step. Any cv-qualification conversion is
4002  // subsumed by the initialization.
4004  Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,
4005  IsListInit | IsInitListCopy, AsInitializerList);
4006 }
4007 
4008 static bool
4010  Expr *Initializer,
4011  QualType &SourceType,
4012  QualType &UnqualifiedSourceType,
4013  QualType UnqualifiedTargetType,
4014  InitializationSequence &Sequence) {
4015  if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
4016  S.Context.OverloadTy) {
4017  DeclAccessPair Found;
4018  bool HadMultipleCandidates = false;
4019  if (FunctionDecl *Fn
4020  = S.ResolveAddressOfOverloadedFunction(Initializer,
4021  UnqualifiedTargetType,
4022  false, Found,
4023  &HadMultipleCandidates)) {
4024  Sequence.AddAddressOverloadResolutionStep(Fn, Found,
4025  HadMultipleCandidates);
4026  SourceType = Fn->getType();
4027  UnqualifiedSourceType = SourceType.getUnqualifiedType();
4028  } else if (!UnqualifiedTargetType->isRecordType()) {
4030  return true;
4031  }
4032  }
4033  return false;
4034 }
4035 
4036 static void TryReferenceInitializationCore(Sema &S,
4037  const InitializedEntity &Entity,
4038  const InitializationKind &Kind,
4039  Expr *Initializer,
4040  QualType cv1T1, QualType T1,
4041  Qualifiers T1Quals,
4042  QualType cv2T2, QualType T2,
4043  Qualifiers T2Quals,
4044  InitializationSequence &Sequence);
4045 
4046 static void TryValueInitialization(Sema &S,
4047  const InitializedEntity &Entity,
4048  const InitializationKind &Kind,
4049  InitializationSequence &Sequence,
4050  InitListExpr *InitList = nullptr);
4051 
4052 /// Attempt list initialization of a reference.
4054  const InitializedEntity &Entity,
4055  const InitializationKind &Kind,
4056  InitListExpr *InitList,
4057  InitializationSequence &Sequence,
4058  bool TreatUnavailableAsInvalid) {
4059  // First, catch C++03 where this isn't possible.
4060  if (!S.getLangOpts().CPlusPlus11) {
4062  return;
4063  }
4064  // Can't reference initialize a compound literal.
4067  return;
4068  }
4069 
4070  QualType DestType = Entity.getType();
4071  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
4072  Qualifiers T1Quals;
4073  QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
4074 
4075  // Reference initialization via an initializer list works thus:
4076  // If the initializer list consists of a single element that is
4077  // reference-related to the referenced type, bind directly to that element
4078  // (possibly creating temporaries).
4079  // Otherwise, initialize a temporary with the initializer list and
4080  // bind to that.
4081  if (InitList->getNumInits() == 1) {
4082  Expr *Initializer = InitList->getInit(0);
4083  QualType cv2T2 = Initializer->getType();
4084  Qualifiers T2Quals;
4085  QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
4086 
4087  // If this fails, creating a temporary wouldn't work either.
4088  if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
4089  T1, Sequence))
4090  return;
4091 
4092  SourceLocation DeclLoc = Initializer->getBeginLoc();
4093  bool dummy1, dummy2, dummy3;
4094  Sema::ReferenceCompareResult RefRelationship
4095  = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
4096  dummy2, dummy3);
4097  if (RefRelationship >= Sema::Ref_Related) {
4098  // Try to bind the reference here.
4099  TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
4100  T1Quals, cv2T2, T2, T2Quals, Sequence);
4101  if (Sequence)
4102  Sequence.RewrapReferenceInitList(cv1T1, InitList);
4103  return;
4104  }
4105 
4106  // Update the initializer if we've resolved an overloaded function.
4107  if (Sequence.step_begin() != Sequence.step_end())
4108  Sequence.RewrapReferenceInitList(cv1T1, InitList);
4109  }
4110 
4111  // Not reference-related. Create a temporary and bind to that.
4113 
4114  TryListInitialization(S, TempEntity, Kind, InitList, Sequence,
4115  TreatUnavailableAsInvalid);
4116  if (Sequence) {
4117  if (DestType->isRValueReferenceType() ||
4118  (T1Quals.hasConst() && !T1Quals.hasVolatile()))
4119  Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
4120  else
4121  Sequence.SetFailed(
4123  }
4124 }
4125 
4126 /// Attempt list initialization (C++0x [dcl.init.list])
4128  const InitializedEntity &Entity,
4129  const InitializationKind &Kind,
4130  InitListExpr *InitList,
4131  InitializationSequence &Sequence,
4132  bool TreatUnavailableAsInvalid) {
4133  QualType DestType = Entity.getType();
4134 
4135  // C++ doesn't allow scalar initialization with more than one argument.
4136  // But C99 complex numbers are scalars and it makes sense there.
4137  if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
4138  !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
4140  return;
4141  }
4142  if (DestType->isReferenceType()) {
4143  TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence,
4144  TreatUnavailableAsInvalid);
4145  return;
4146  }
4147 
4148  if (DestType->isRecordType() &&
4149  !S.isCompleteType(InitList->getBeginLoc(), DestType)) {
4150  Sequence.setIncompleteTypeFailure(DestType);
4151  return;
4152  }
4153 
4154  // C++11 [dcl.init.list]p3, per DR1467:
4155  // - If T is a class type and the initializer list has a single element of
4156  // type cv U, where U is T or a class derived from T, the object is
4157  // initialized from that element (by copy-initialization for
4158  // copy-list-initialization, or by direct-initialization for
4159  // direct-list-initialization).
4160  // - Otherwise, if T is a character array and the initializer list has a
4161  // single element that is an appropriately-typed string literal
4162  // (8.5.2 [dcl.init.string]), initialization is performed as described
4163  // in that section.
4164  // - Otherwise, if T is an aggregate, [...] (continue below).
4165  if (S.getLangOpts().CPlusPlus11 && InitList->getNumInits() == 1) {
4166  if (DestType->isRecordType()) {
4167  QualType InitType = InitList->getInit(0)->getType();
4168  if (S.Context.hasSameUnqualifiedType(InitType, DestType) ||
4169  S.IsDerivedFrom(InitList->getBeginLoc(), InitType, DestType)) {
4170  Expr *InitListAsExpr = InitList;
4171  TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
4172  DestType, Sequence,
4173  /*InitListSyntax*/false,
4174  /*IsInitListCopy*/true);
4175  return;
4176  }
4177  }
4178  if (const ArrayType *DestAT = S.Context.getAsArrayType(DestType)) {
4179  Expr *SubInit[1] = {InitList->getInit(0)};
4180  if (!isa<VariableArrayType>(DestAT) &&
4181  IsStringInit(SubInit[0], DestAT, S.Context) == SIF_None) {
4182  InitializationKind SubKind =
4185  InitList->getLBraceLoc(),
4186  InitList->getRBraceLoc())
4187  : Kind;
4188  Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
4189  /*TopLevelOfInitList*/ true,
4190  TreatUnavailableAsInvalid);
4191 
4192  // TryStringLiteralInitialization() (in InitializeFrom()) will fail if
4193  // the element is not an appropriately-typed string literal, in which
4194  // case we should proceed as in C++11 (below).
4195  if (Sequence) {
4196  Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
4197  return;
4198  }
4199  }
4200  }
4201  }
4202 
4203  // C++11 [dcl.init.list]p3:
4204  // - If T is an aggregate, aggregate initialization is performed.
4205  if ((DestType->isRecordType() && !DestType->isAggregateType()) ||
4206  (S.getLangOpts().CPlusPlus11 &&
4207  S.isStdInitializerList(DestType, nullptr))) {
4208  if (S.getLangOpts().CPlusPlus11) {
4209  // - Otherwise, if the initializer list has no elements and T is a
4210  // class type with a default constructor, the object is
4211  // value-initialized.
4212  if (InitList->getNumInits() == 0) {
4213  CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
4214  if (RD->hasDefaultConstructor()) {
4215  TryValueInitialization(S, Entity, Kind, Sequence, InitList);
4216  return;
4217  }
4218  }
4219 
4220  // - Otherwise, if T is a specialization of std::initializer_list<E>,
4221  // an initializer_list object constructed [...]
4222  if (TryInitializerListConstruction(S, InitList, DestType, Sequence,
4223  TreatUnavailableAsInvalid))
4224  return;
4225 
4226  // - Otherwise, if T is a class type, constructors are considered.
4227  Expr *InitListAsExpr = InitList;
4228  TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
4229  DestType, Sequence, /*InitListSyntax*/true);
4230  } else
4232  return;
4233  }
4234 
4235  if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() &&
4236  InitList->getNumInits() == 1) {
4237  Expr *E = InitList->getInit(0);
4238 
4239  // - Otherwise, if T is an enumeration with a fixed underlying type,
4240  // the initializer-list has a single element v, and the initialization
4241  // is direct-list-initialization, the object is initialized with the
4242  // value T(v); if a narrowing conversion is required to convert v to
4243  // the underlying type of T, the program is ill-formed.
4244  auto *ET = DestType->getAs<EnumType>();
4245  if (S.getLangOpts().CPlusPlus17 &&
4247  ET && ET->getDecl()->isFixed() &&
4248  !S.Context.hasSameUnqualifiedType(E->getType(), DestType) &&
4250  E->getType()->isFloatingType())) {
4251  // There are two ways that T(v) can work when T is an enumeration type.
4252  // If there is either an implicit conversion sequence from v to T or
4253  // a conversion function that can convert from v to T, then we use that.
4254  // Otherwise, if v is of integral, enumeration, or floating-point type,
4255  // it is converted to the enumeration type via its underlying type.
4256  // There is no overlap possible between these two cases (except when the
4257  // source value is already of the destination type), and the first
4258  // case is handled by the general case for single-element lists below.
4260  ICS.setStandard();
4262  if (!E->isRValue())
4264  // If E is of a floating-point type, then the conversion is ill-formed
4265  // due to narrowing, but go through the motions in order to produce the
4266  // right diagnostic.
4267  ICS.Standard.Second = E->getType()->isFloatingType()
4270  ICS.Standard.setFromType(E->getType());
4271  ICS.Standard.setToType(0, E->getType());
4272  ICS.Standard.setToType(1, DestType);
4273  ICS.Standard.setToType(2, DestType);
4274  Sequence.AddConversionSequenceStep(ICS, ICS.Standard.getToType(2),
4275  /*TopLevelOfInitList*/true);
4276  Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
4277  return;
4278  }
4279 
4280  // - Otherwise, if the initializer list has a single element of type E
4281  // [...references are handled above...], the object or reference is
4282  // initialized from that element (by copy-initialization for
4283  // copy-list-initialization, or by direct-initialization for
4284  // direct-list-initialization); if a narrowing conversion is required
4285  // to convert the element to T, the program is ill-formed.
4286  //
4287  // Per core-24034, this is direct-initialization if we were performing
4288  // direct-list-initialization and copy-initialization otherwise.
4289  // We can't use InitListChecker for this, because it always performs
4290  // copy-initialization. This only matters if we might use an 'explicit'
4291  // conversion operator, so we only need to handle the cases where the source
4292  // is of record type.
4293  if (InitList->getInit(0)->getType()->isRecordType()) {
4294  InitializationKind SubKind =
4297  InitList->getLBraceLoc(),
4298  InitList->getRBraceLoc())
4299  : Kind;
4300  Expr *SubInit[1] = { InitList->getInit(0) };
4301  Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
4302  /*TopLevelOfInitList*/true,
4303  TreatUnavailableAsInvalid);
4304  if (Sequence)
4305  Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
4306  return;
4307  }
4308  }
4309 
4310  InitListChecker CheckInitList(S, Entity, InitList,
4311  DestType, /*VerifyOnly=*/true, TreatUnavailableAsInvalid);
4312  if (CheckInitList.HadError()) {
4314  return;
4315  }
4316 
4317  // Add the list initialization step with the built init list.
4318  Sequence.AddListInitializationStep(DestType);
4319 }
4320 
4321 /// Try a reference initialization that involves calling a conversion
4322 /// function.
4324  Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind,
4325  Expr *Initializer, bool AllowRValues, bool IsLValueRef,
4326  InitializationSequence &Sequence) {
4327  QualType DestType = Entity.getType();
4328  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
4329  QualType T1 = cv1T1.getUnqualifiedType();
4330  QualType cv2T2 = Initializer->getType();
4331  QualType T2 = cv2T2.getUnqualifiedType();
4332 
4333  bool DerivedToBase;
4334  bool ObjCConversion;
4335  bool ObjCLifetimeConversion;
4336  assert(!S.CompareReferenceRelationship(Initializer->getBeginLoc(), T1, T2,
4337  DerivedToBase, ObjCConversion,
4338  ObjCLifetimeConversion) &&
4339  "Must have incompatible references when binding via conversion");
4340  (void)DerivedToBase;
4341  (void)ObjCConversion;
4342  (void)ObjCLifetimeConversion;
4343 
4344  // Build the candidate set directly in the initialization sequence
4345  // structure, so that it will persist if we fail.
4346  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4348 
4349  // Determine whether we are allowed to call explicit conversion operators.
4350  // Note that none of [over.match.copy], [over.match.conv], nor
4351  // [over.match.ref] permit an explicit constructor to be chosen when
4352  // initializing a reference, not even for direct-initialization.
4353  bool AllowExplicitCtors = false;
4354  bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
4355 
4356  const RecordType *T1RecordType = nullptr;
4357  if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
4358  S.isCompleteType(Kind.getLocation(), T1)) {
4359  // The type we're converting to is a class type. Enumerate its constructors
4360  // to see if there is a suitable conversion.
4361  CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
4362 
4363  for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) {
4364  auto Info = getConstructorInfo(D);
4365  if (!Info.Constructor)
4366  continue;
4367 
4368  if (!Info.Constructor->isInvalidDecl() &&
4369  Info.Constructor->isConvertingConstructor(AllowExplicitCtors)) {
4370  if (Info.ConstructorTmpl)
4371  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
4372  /*ExplicitArgs*/ nullptr,
4373  Initializer, CandidateSet,
4374  /*SuppressUserConversions=*/true);
4375  else
4376  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
4377  Initializer, CandidateSet,
4378  /*SuppressUserConversions=*/true);
4379  }
4380  }
4381  }
4382  if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
4383  return OR_No_Viable_Function;
4384 
4385  const RecordType *T2RecordType = nullptr;
4386  if ((T2RecordType = T2->getAs<RecordType>()) &&
4387  S.isCompleteType(Kind.getLocation(), T2)) {
4388  // The type we're converting from is a class type, enumerate its conversion
4389  // functions.
4390  CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
4391 
4392  const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4393  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4394  NamedDecl *D = *I;
4395  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4396  if (isa<UsingShadowDecl>(D))
4397  D = cast<UsingShadowDecl>(D)->getTargetDecl();
4398 
4399  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4400  CXXConversionDecl *Conv;
4401  if (ConvTemplate)
4402  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4403  else
4404  Conv = cast<CXXConversionDecl>(D);
4405 
4406  // If the conversion function doesn't return a reference type,
4407  // it can't be considered for this conversion unless we're allowed to
4408  // consider rvalues.
4409  // FIXME: Do we need to make sure that we only consider conversion
4410  // candidates with reference-compatible results? That might be needed to
4411  // break recursion.
4412  if ((AllowExplicitConvs || !Conv->isExplicit()) &&
4413  (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
4414  if (ConvTemplate)
4415  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4416  ActingDC, Initializer,
4417  DestType, CandidateSet,
4418  /*AllowObjCConversionOnExplicit=*/
4419  false);
4420  else
4421  S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4422  Initializer, DestType, CandidateSet,
4423  /*AllowObjCConversionOnExplicit=*/false);
4424  }
4425  }
4426  }
4427  if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
4428  return OR_No_Viable_Function;
4429 
4430  SourceLocation DeclLoc = Initializer->getBeginLoc();
4431 
4432  // Perform overload resolution. If it fails, return the failed result.
4435  = CandidateSet.BestViableFunction(S, DeclLoc, Best))
4436  return Result;
4437 
4438  FunctionDecl *Function = Best->Function;
4439  // This is the overload that will be used for this initialization step if we
4440  // use this initialization. Mark it as referenced.
4441  Function->setReferenced();
4442 
4443  // Compute the returned type and value kind of the conversion.
4444  QualType cv3T3;
4445  if (isa<CXXConversionDecl>(Function))
4446  cv3T3 = Function->getReturnType();
4447  else
4448  cv3T3 = T1;
4449 
4450  ExprValueKind VK = VK_RValue;
4451  if (cv3T3->isLValueReferenceType())
4452  VK = VK_LValue;
4453  else if (const auto *RRef = cv3T3->getAs<RValueReferenceType>())
4454  VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
4455  cv3T3 = cv3T3.getNonLValueExprType(S.Context);
4456 
4457  // Add the user-defined conversion step.
4458  bool HadMultipleCandidates = (CandidateSet.size() > 1);
4459  Sequence.AddUserConversionStep(Function, Best->FoundDecl, cv3T3,
4460  HadMultipleCandidates);
4461 
4462  // Determine whether we'll need to perform derived-to-base adjustments or
4463  // other conversions.
4464  bool NewDerivedToBase = false;
4465  bool NewObjCConversion = false;
4466  bool NewObjCLifetimeConversion = false;
4467  Sema::ReferenceCompareResult NewRefRelationship
4468  = S.CompareReferenceRelationship(DeclLoc, T1, cv3T3,
4469  NewDerivedToBase, NewObjCConversion,
4470  NewObjCLifetimeConversion);
4471 
4472  // Add the final conversion sequence, if necessary.
4473  if (NewRefRelationship == Sema::Ref_Incompatible) {
4474  assert(!isa<CXXConstructorDecl>(Function) &&
4475  "should not have conversion after constructor");
4476 
4478  ICS.setStandard();
4479  ICS.Standard = Best->FinalConversion;
4480  Sequence.AddConversionSequenceStep(ICS, ICS.Standard.getToType(2));
4481 
4482  // Every implicit conversion results in a prvalue, except for a glvalue
4483  // derived-to-base conversion, which we handle below.
4484  cv3T3 = ICS.Standard.getToType(2);
4485  VK = VK_RValue;
4486  }
4487 
4488  // If the converted initializer is a prvalue, its type T4 is adjusted to
4489  // type "cv1 T4" and the temporary materialization conversion is applied.
4490  //
4491  // We adjust the cv-qualifications to match the reference regardless of
4492  // whether we have a prvalue so that the AST records the change. In this
4493  // case, T4 is "cv3 T3".
4494  QualType cv1T4 = S.Context.getQualifiedType(cv3T3, cv1T1.getQualifiers());
4495  if (cv1T4.getQualifiers() != cv3T3.getQualifiers())
4496  Sequence.AddQualificationConversionStep(cv1T4, VK);
4497  Sequence.AddReferenceBindingStep(cv1T4, VK == VK_RValue);
4498  VK = IsLValueRef ? VK_LValue : VK_XValue;
4499 
4500  if (NewDerivedToBase)
4501  Sequence.AddDerivedToBaseCastStep(cv1T1, VK);
4502  else if (NewObjCConversion)
4503  Sequence.AddObjCObjectConversionStep(cv1T1);
4504 
4505  return OR_Success;
4506 }
4507 
4508 static void CheckCXX98CompatAccessibleCopy(Sema &S,
4509  const InitializedEntity &Entity,
4510  Expr *CurInitExpr);
4511 
4512 /// Attempt reference initialization (C++0x [dcl.init.ref])
4514  const InitializedEntity &Entity,
4515  const InitializationKind &Kind,
4516  Expr *Initializer,
4517  InitializationSequence &Sequence) {
4518  QualType DestType = Entity.getType();
4519  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
4520  Qualifiers T1Quals;
4521  QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
4522  QualType cv2T2 = Initializer->getType();
4523  Qualifiers T2Quals;
4524  QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
4525 
4526  // If the initializer is the address of an overloaded function, try
4527  // to resolve the overloaded function. If all goes well, T2 is the
4528  // type of the resulting function.
4529  if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
4530  T1, Sequence))
4531  return;
4532 
4533  // Delegate everything else to a subfunction.
4534  TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
4535  T1Quals, cv2T2, T2, T2Quals, Sequence);
4536 }
4537 
4538 /// Determine whether an expression is a non-referenceable glvalue (one to
4539 /// which a reference can never bind). Attempting to bind a reference to
4540 /// such a glvalue will always create a temporary.
4542  return E->refersToBitField() || E->refersToVectorElement();
4543 }
4544 
4545 /// Reference initialization without resolving overloaded functions.
4547  const InitializedEntity &Entity,
4548  const InitializationKind &Kind,
4549  Expr *Initializer,
4550  QualType cv1T1, QualType T1,
4551  Qualifiers T1Quals,
4552  QualType cv2T2, QualType T2,
4553  Qualifiers T2Quals,
4554  InitializationSequence &Sequence) {
4555  QualType DestType = Entity.getType();
4556  SourceLocation DeclLoc = Initializer->getBeginLoc();
4557  // Compute some basic properties of the types and the initializer.
4558  bool isLValueRef = DestType->isLValueReferenceType();
4559  bool isRValueRef = !isLValueRef;
4560  bool DerivedToBase = false;
4561  bool ObjCConversion = false;
4562  bool ObjCLifetimeConversion = false;
4563  Expr::Classification InitCategory = Initializer->Classify(S.Context);
4564  Sema::ReferenceCompareResult RefRelationship
4565  = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
4566  ObjCConversion, ObjCLifetimeConversion);
4567 
4568  // C++0x [dcl.init.ref]p5:
4569  // A reference to type "cv1 T1" is initialized by an expression of type
4570  // "cv2 T2" as follows:
4571  //
4572  // - If the reference is an lvalue reference and the initializer
4573  // expression
4574  // Note the analogous bullet points for rvalue refs to functions. Because
4575  // there are no function rvalues in C++, rvalue refs to functions are treated
4576  // like lvalue refs.
4577  OverloadingResult ConvOvlResult = OR_Success;
4578  bool T1Function = T1->isFunctionType();
4579  if (isLValueRef || T1Function) {
4580  if (InitCategory.isLValue() && !isNonReferenceableGLValue(Initializer) &&
4581  (RefRelationship == Sema::Ref_Compatible ||
4582  (Kind.isCStyleOrFunctionalCast() &&
4583  RefRelationship == Sema::Ref_Related))) {
4584  // - is an lvalue (but is not a bit-field), and "cv1 T1" is
4585  // reference-compatible with "cv2 T2," or
4586  if (T1Quals != T2Quals)
4587  // Convert to cv1 T2. This should only add qualifiers unless this is a
4588  // c-style cast. The removal of qualifiers in that case notionally
4589  // happens after the reference binding, but that doesn't matter.
4591  S.Context.getQualifiedType(T2, T1Quals),
4592  Initializer->getValueKind());
4593  if (DerivedToBase)
4594  Sequence.AddDerivedToBaseCastStep(cv1T1, VK_LValue);
4595  else if (ObjCConversion)
4596  Sequence.AddObjCObjectConversionStep(cv1T1);
4597 
4598  // We only create a temporary here when binding a reference to a
4599  // bit-field or vector element. Those cases are't supposed to be
4600  // handled by this bullet, but the outcome is the same either way.
4601  Sequence.AddReferenceBindingStep(cv1T1, false);
4602  return;
4603  }
4604 
4605  // - has a class type (i.e., T2 is a class type), where T1 is not
4606  // reference-related to T2, and can be implicitly converted to an
4607  // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
4608  // with "cv3 T3" (this conversion is selected by enumerating the
4609  // applicable conversion functions (13.3.1.6) and choosing the best
4610  // one through overload resolution (13.3)),
4611  // If we have an rvalue ref to function type here, the rhs must be
4612  // an rvalue. DR1287 removed the "implicitly" here.
4613  if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
4614  (isLValueRef || InitCategory.isRValue())) {
4615  ConvOvlResult = TryRefInitWithConversionFunction(
4616  S, Entity, Kind, Initializer, /*AllowRValues*/ isRValueRef,
4617  /*IsLValueRef*/ isLValueRef, Sequence);
4618  if (ConvOvlResult == OR_Success)
4619  return;
4620  if (ConvOvlResult != OR_No_Viable_Function)
4621  Sequence.SetOverloadFailure(
4623  ConvOvlResult);
4624  }
4625  }
4626 
4627  // - Otherwise, the reference shall be an lvalue reference to a
4628  // non-volatile const type (i.e., cv1 shall be const), or the reference
4629  // shall be an rvalue reference.
4630  if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
4631  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4633  else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4634  Sequence.SetOverloadFailure(
4636  ConvOvlResult);
4637  else if (!InitCategory.isLValue())
4638  Sequence.SetFailed(
4640  else {
4642  switch (RefRelationship) {
4643  case Sema::Ref_Compatible:
4644  if (Initializer->refersToBitField())
4645  FK = InitializationSequence::
4646  FK_NonConstLValueReferenceBindingToBitfield;
4647  else if (Initializer->refersToVectorElement())
4648  FK = InitializationSequence::
4649  FK_NonConstLValueReferenceBindingToVectorElement;
4650  else
4651  llvm_unreachable("unexpected kind of compatible initializer");
4652  break;
4653  case Sema::Ref_Related:
4655  break;
4659  break;
4660  }
4661  Sequence.SetFailed(FK);
4662  }
4663  return;
4664  }
4665 
4666  // - If the initializer expression
4667  // - is an
4668  // [<=14] xvalue (but not a bit-field), class prvalue, array prvalue, or
4669  // [1z] rvalue (but not a bit-field) or
4670  // function lvalue and "cv1 T1" is reference-compatible with "cv2 T2"
4671  //
4672  // Note: functions are handled above and below rather than here...
4673  if (!T1Function &&
4674  (RefRelationship == Sema::Ref_Compatible ||
4675  (Kind.isCStyleOrFunctionalCast() &&
4676  RefRelationship == Sema::Ref_Related)) &&
4677  ((InitCategory.isXValue() && !isNonReferenceableGLValue(Initializer)) ||
4678  (InitCategory.isPRValue() &&
4679  (S.getLangOpts().CPlusPlus17 || T2->isRecordType() ||
4680  T2->isArrayType())))) {
4681  ExprValueKind ValueKind = InitCategory.isXValue() ? VK_XValue : VK_RValue;
4682  if (InitCategory.isPRValue() && T2->isRecordType()) {
4683  // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
4684  // compiler the freedom to perform a copy here or bind to the
4685  // object, while C++0x requires that we bind directly to the
4686  // object. Hence, we always bind to the object without making an
4687  // extra copy. However, in C++03 requires that we check for the
4688  // presence of a suitable copy constructor:
4689  //
4690  // The constructor that would be used to make the copy shall
4691  // be callable whether or not the copy is actually done.
4692  if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
4693  Sequence.AddExtraneousCopyToTemporary(cv2T2);
4694  else if (S.getLangOpts().CPlusPlus11)
4695  CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
4696  }
4697 
4698  // C++1z [dcl.init.ref]/5.2.1.2:
4699  // If the converted initializer is a prvalue, its type T4 is adjusted
4700  // to type "cv1 T4" and the temporary materialization conversion is
4701  // applied.
4702  // Postpone address space conversions to after the temporary materialization
4703  // conversion to allow creating temporaries in the alloca address space.
4704  auto T1QualsIgnoreAS = T1Quals;
4705  auto T2QualsIgnoreAS = T2Quals;
4706  if (T1Quals.getAddressSpace() != T2Quals.getAddressSpace()) {
4707  T1QualsIgnoreAS.removeAddressSpace();
4708  T2QualsIgnoreAS.removeAddressSpace();
4709  }
4710  QualType cv1T4 = S.Context.getQualifiedType(cv2T2, T1QualsIgnoreAS);
4711  if (T1QualsIgnoreAS != T2QualsIgnoreAS)
4712  Sequence.AddQualificationConversionStep(cv1T4, ValueKind);
4713  Sequence.AddReferenceBindingStep(cv1T4, ValueKind == VK_RValue);
4714  ValueKind = isLValueRef ? VK_LValue : VK_XValue;
4715  // Add addr space conversion if required.
4716  if (T1Quals.getAddressSpace() != T2Quals.getAddressSpace()) {
4717  auto T4Quals = cv1T4.getQualifiers();
4718  T4Quals.addAddressSpace(T1Quals.getAddressSpace());
4719  QualType cv1T4WithAS = S.Context.getQualifiedType(T2, T4Quals);
4720  Sequence.AddQualificationConversionStep(cv1T4WithAS, ValueKind);
4721  }
4722 
4723  // In any case, the reference is bound to the resulting glvalue (or to
4724  // an appropriate base class subobject).
4725  if (DerivedToBase)
4726  Sequence.AddDerivedToBaseCastStep(cv1T1, ValueKind);
4727  else if (ObjCConversion)
4728  Sequence.AddObjCObjectConversionStep(cv1T1);
4729  return;
4730  }
4731 
4732  // - has a class type (i.e., T2 is a class type), where T1 is not
4733  // reference-related to T2, and can be implicitly converted to an
4734  // xvalue, class prvalue, or function lvalue of type "cv3 T3",
4735  // where "cv1 T1" is reference-compatible with "cv3 T3",
4736  //
4737  // DR1287 removes the "implicitly" here.
4738  if (T2->isRecordType()) {
4739  if (RefRelationship == Sema::Ref_Incompatible) {
4740  ConvOvlResult = TryRefInitWithConversionFunction(
4741  S, Entity, Kind, Initializer, /*AllowRValues*/ true,
4742  /*IsLValueRef*/ isLValueRef, Sequence);
4743  if (ConvOvlResult)
4744  Sequence.SetOverloadFailure(
4746  ConvOvlResult);
4747 
4748  return;
4749  }
4750 
4751  if (RefRelationship == Sema::Ref_Compatible &&
4752  isRValueRef && InitCategory.isLValue()) {
4753  Sequence.SetFailed(
4755  return;
4756  }
4757 
4759  return;
4760  }
4761 
4762  // - Otherwise, a temporary of type "cv1 T1" is created and initialized
4763  // from the initializer expression using the rules for a non-reference
4764  // copy-initialization (8.5). The reference is then bound to the
4765  // temporary. [...]
4766 
4767  // Ignore address space of reference type at this point and perform address
4768  // space conversion after the reference binding step.
4769  QualType cv1T1IgnoreAS =
4770  T1Quals.hasAddressSpace()
4771  ? S.Context.getQualifiedType(T1, T1Quals.withoutAddressSpace())
4772  : cv1T1;
4773 
4774  InitializedEntity TempEntity =
4776 
4777  // FIXME: Why do we use an implicit conversion here rather than trying
4778  // copy-initialization?
4780  = S.TryImplicitConversion(Initializer, TempEntity.getType(),
4781  /*SuppressUserConversions=*/false,
4782  /*AllowExplicit=*/false,
4783  /*FIXME:InOverloadResolution=*/false,
4784  /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4785  /*AllowObjCWritebackConversion=*/false);
4786 
4787  if (ICS.isBad()) {
4788  // FIXME: Use the conversion function set stored in ICS to turn
4789  // this into an overloading ambiguity diagnostic. However, we need
4790  // to keep that set as an OverloadCandidateSet rather than as some
4791  // other kind of set.
4792  if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4793  Sequence.SetOverloadFailure(
4795  ConvOvlResult);
4796  else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4798  else
4800  return;
4801  } else {
4802  Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
4803  }
4804 
4805  // [...] If T1 is reference-related to T2, cv1 must be the
4806  // same cv-qualification as, or greater cv-qualification
4807  // than, cv2; otherwise, the program is ill-formed.
4808  unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
4809  unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
4810  if ((RefRelationship == Sema::Ref_Related &&
4811  (T1CVRQuals | T2CVRQuals) != T1CVRQuals) ||
4812  !T1Quals.isAddressSpaceSupersetOf(T2Quals)) {
4814  return;
4815  }
4816 
4817  // [...] If T1 is reference-related to T2 and the reference is an rvalue
4818  // reference, the initializer expression shall not be an lvalue.
4819  if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
4820  InitCategory.isLValue()) {
4821  Sequence.SetFailed(
4823  return;
4824  }
4825 
4826  Sequence.AddReferenceBindingStep(cv1T1IgnoreAS, /*bindingTemporary=*/true);
4827 
4828  if (T1Quals.hasAddressSpace())
4829  Sequence.AddQualificationConversionStep(cv1T1, isLValueRef ? VK_LValue
4830  : VK_XValue);
4831 }
4832 
4833 /// Attempt character array initialization from a string literal
4834 /// (C++ [dcl.init.string], C99 6.7.8).
4836  const InitializedEntity &Entity,
4837  const InitializationKind &Kind,
4838  Expr *Initializer,
4839  InitializationSequence &Sequence) {
4840  Sequence.AddStringInitStep(Entity.getType());
4841 }
4842 
4843 /// Attempt value initialization (C++ [dcl.init]p7).
4845  const InitializedEntity &Entity,
4846  const InitializationKind &Kind,
4847  InitializationSequence &Sequence,
4848  InitListExpr *InitList) {
4849  assert((!InitList || InitList->getNumInits() == 0) &&
4850  "Shouldn't use value-init for non-empty init lists");
4851 
4852  // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
4853  //
4854  // To value-initialize an object of type T means:
4855  QualType T = Entity.getType();
4856 
4857  // -- if T is an array type, then each element is value-initialized;
4858  T = S.Context.getBaseElementType(T);
4859 
4860  if (const RecordType *RT = T->getAs<RecordType>()) {
4861  if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
4862  bool NeedZeroInitialization = true;
4863  // C++98:
4864  // -- if T is a class type (clause 9) with a user-declared constructor
4865  // (12.1), then the default constructor for T is called (and the
4866  // initialization is ill-formed if T has no accessible default
4867  // constructor);
4868  // C++11:
4869  // -- if T is a class type (clause 9) with either no default constructor
4870  // (12.1 [class.ctor]) or a default constructor that is user-provided
4871  // or deleted, then the object is default-initialized;
4872  //
4873  // Note that the C++11 rule is the same as the C++98 rule if there are no
4874  // defaulted or deleted constructors, so we just use it unconditionally.
4875  CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
4876  if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
4877  NeedZeroInitialization = false;
4878 
4879  // -- if T is a (possibly cv-qualified) non-union class type without a
4880  // user-provided or deleted default constructor, then the object is
4881  // zero-initialized and, if T has a non-trivial default constructor,
4882  // default-initialized;
4883  // The 'non-union' here was removed by DR1502. The 'non-trivial default
4884  // constructor' part was removed by DR1507.
4885  if (NeedZeroInitialization)
4886  Sequence.AddZeroInitializationStep(Entity.getType());
4887 
4888  // C++03:
4889  // -- if T is a non-union class type without a user-declared constructor,
4890  // then every non-static data member and base class component of T is
4891  // value-initialized;
4892  // [...] A program that calls for [...] value-initialization of an
4893  // entity of reference type is ill-formed.
4894  //
4895  // C++11 doesn't need this handling, because value-initialization does not
4896  // occur recursively there, and the implicit default constructor is
4897  // defined as deleted in the problematic cases.
4898  if (!S.getLangOpts().CPlusPlus11 &&
4899  ClassDecl->hasUninitializedReferenceMember()) {
4901  return;
4902  }
4903 
4904  // If this is list-value-initialization, pass the empty init list on when
4905  // building the constructor call. This affects the semantics of a few
4906  // things (such as whether an explicit default constructor can be called).
4907  Expr *InitListAsExpr = InitList;
4908  MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
4909  bool InitListSyntax = InitList;
4910 
4911  // FIXME: Instead of creating a CXXConstructExpr of array type here,
4912  // wrap a class-typed CXXConstructExpr in an ArrayInitLoopExpr.
4914  S, Entity, Kind, Args, T, Entity.getType(), Sequence, InitListSyntax);
4915  }
4916  }
4917 
4918  Sequence.AddZeroInitializationStep(Entity.getType());
4919 }
4920 
4921 /// Attempt default initialization (C++ [dcl.init]p6).
4923  const InitializedEntity &Entity,
4924  const InitializationKind &Kind,
4925  InitializationSequence &Sequence) {
4926  assert(Kind.getKind() == InitializationKind::IK_Default);
4927 
4928  // C++ [dcl.init]p6:
4929  // To default-initialize an object of type T means:
4930  // - if T is an array type, each element is default-initialized;
4931  QualType DestType = S.Context.getBaseElementType(Entity.getType());
4932 
4933  // - if T is a (possibly cv-qualified) class type (Clause 9), the default
4934  // constructor for T is called (and the initialization is ill-formed if
4935  // T has no accessible default constructor);
4936  if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
4937  TryConstructorInitialization(S, Entity, Kind, None, DestType,
4938  Entity.getType(), Sequence);
4939  return;
4940  }
4941 
4942  // - otherwise, no initialization is performed.
4943 
4944  // If a program calls for the default initialization of an object of
4945  // a const-qualified type T, T shall be a class type with a user-provided
4946  // default constructor.
4947  if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
4948  if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
4950  return;
4951  }
4952 
4953  // If the destination type has a lifetime property, zero-initialize it.
4954  if (DestType.getQualifiers().hasObjCLifetime()) {
4955  Sequence.AddZeroInitializationStep(Entity.getType());
4956  return;
4957  }
4958 }
4959 
4960 /// Attempt a user-defined conversion between two types (C++ [dcl.init]),
4961 /// which enumerates all conversion functions and performs overload resolution
4962 /// to select the best.
4964  QualType DestType,
4965  const InitializationKind &Kind,
4966  Expr *Initializer,
4967  InitializationSequence &Sequence,
4968  bool TopLevelOfInitList) {
4969  assert(!DestType->isReferenceType() && "References are handled elsewhere");
4970  QualType SourceType = Initializer->getType();
4971  assert((DestType->isRecordType() || SourceType->isRecordType()) &&
4972  "Must have a class type to perform a user-defined conversion");
4973 
4974  // Build the candidate set directly in the initialization sequence
4975  // structure, so that it will persist if we fail.
4976  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4978 
4979  // Determine whether we are allowed to call explicit constructors or
4980  // explicit conversion operators.
4981  bool AllowExplicit = Kind.AllowExplicit();
4982 
4983  if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4984  // The type we're converting to is a class type. Enumerate its constructors
4985  // to see if there is a suitable conversion.
4986  CXXRecordDecl *DestRecordDecl
4987  = cast<CXXRecordDecl>(DestRecordType->getDecl());
4988 
4989  // Try to complete the type we're converting to.
4990  if (S.isCompleteType(Kind.getLocation(), DestType)) {
4991  for (NamedDecl *D : S.LookupConstructors(DestRecordDecl)) {
4992  auto Info = getConstructorInfo(D);
4993  if (!Info.Constructor)
4994  continue;
4995 
4996  if (!Info.Constructor->isInvalidDecl() &&
4997  Info.Constructor->isConvertingConstructor(AllowExplicit)) {
4998  if (Info.ConstructorTmpl)
4999  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
5000  /*ExplicitArgs*/ nullptr,
5001  Initializer, CandidateSet,
5002  /*SuppressUserConversions=*/true);
5003  else
5004  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
5005  Initializer, CandidateSet,
5006  /*SuppressUserConversions=*/true);
5007  }
5008  }
5009  }
5010  }
5011 
5012  SourceLocation DeclLoc = Initializer->getBeginLoc();
5013 
5014  if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
5015  // The type we're converting from is a class type, enumerate its conversion
5016  // functions.
5017 
5018  // We can only enumerate the conversion functions for a complete type; if
5019  // the type isn't complete, simply skip this step.
5020  if (S.isCompleteType(DeclLoc, SourceType)) {
5021  CXXRecordDecl *SourceRecordDecl
5022  = cast<CXXRecordDecl>(SourceRecordType->getDecl());
5023 
5024  const auto &Conversions =
5025  SourceRecordDecl->getVisibleConversionFunctions();
5026  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
5027  NamedDecl *D = *I;
5028  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
5029  if (isa<UsingShadowDecl>(D))
5030  D = cast<UsingShadowDecl>(D)->getTargetDecl();
5031 
5032  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
5033  CXXConversionDecl *Conv;
5034  if (ConvTemplate)
5035  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
5036  else
5037  Conv = cast<CXXConversionDecl>(D);
5038 
5039  if (AllowExplicit || !Conv->isExplicit()) {
5040  if (ConvTemplate)
5041  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
5042  ActingDC, Initializer, DestType,
5043  CandidateSet, AllowExplicit);
5044  else
5045  S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
5046  Initializer, DestType, CandidateSet,
5047  AllowExplicit);
5048  }
5049  }
5050  }
5051  }
5052 
5053  // Perform overload resolution. If it fails, return the failed result.
5056  = CandidateSet.BestViableFunction(S, DeclLoc, Best)) {
5057  Sequence.SetOverloadFailure(
5059  Result);
5060  return;
5061  }
5062 
5063  FunctionDecl *Function = Best->Function;
5064  Function->setReferenced();
5065  bool HadMultipleCandidates = (CandidateSet.size() > 1);
5066 
5067  if (isa<CXXConstructorDecl>(Function)) {
5068  // Add the user-defined conversion step. Any cv-qualification conversion is
5069  // subsumed by the initialization. Per DR5, the created temporary is of the
5070  // cv-unqualified type of the destination.
5071  Sequence.AddUserConversionStep(Function, Best->FoundDecl,
5072  DestType.getUnqualifiedType(),
5073  HadMultipleCandidates);
5074 
5075  // C++14 and before:
5076  // - if the function is a constructor, the call initializes a temporary
5077  // of the cv-unqualified version of the destination type. The [...]
5078  // temporary [...] is then used to direct-initialize, according to the
5079  // rules above, the object that is the destination of the
5080  // copy-initialization.
5081  // Note that this just performs a simple object copy from the temporary.
5082  //
5083  // C++17:
5084  // - if the function is a constructor, the call is a prvalue of the
5085  // cv-unqualified version of the destination type whose return object
5086  // is initialized by the constructor. The call is used to
5087  // direct-initialize, according to the rules above, the object that
5088  // is the destination of the copy-initialization.
5089  // Therefore we need to do nothing further.
5090  //
5091  // FIXME: Mark this copy as extraneous.
5092  if (!S.getLangOpts().CPlusPlus17)
5093  Sequence.AddFinalCopy(DestType);
5094  else if (DestType.hasQualifiers())
5095  Sequence.AddQualificationConversionStep(DestType, VK_RValue);
5096  return;
5097  }
5098 
5099  // Add the user-defined conversion step that calls the conversion function.
5100  QualType ConvType = Function->getCallResultType();
5101  Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
5102  HadMultipleCandidates);
5103 
5104  if (ConvType->getAs<RecordType>()) {
5105  // The call is used to direct-initialize [...] the object that is the
5106  // destination of the copy-initialization.
5107  //
5108  // In C++17, this does not call a constructor if we enter /17.6.1:
5109  // - If the initializer expression is a prvalue and the cv-unqualified
5110  // version of the source type is the same as the class of the
5111  // destination [... do not make an extra copy]
5112  //
5113  // FIXME: Mark this copy as extraneous.
5114  if (!S.getLangOpts().CPlusPlus17 ||
5115  Function->getReturnType()->isReferenceType() ||
5116  !S.Context.hasSameUnqualifiedType(ConvType, DestType))
5117  Sequence.AddFinalCopy(DestType);
5118  else if (!S.Context.hasSameType(ConvType, DestType))
5119  Sequence.AddQualificationConversionStep(DestType, VK_RValue);
5120  return;
5121  }
5122 
5123  // If the conversion following the call to the conversion function
5124  // is interesting, add it as a separate step.
5125  if (Best->FinalConversion.First || Best->FinalConversion.Second ||
5126  Best->FinalConversion.Third) {
5128  ICS.setStandard();
5129  ICS.Standard = Best->FinalConversion;
5130  Sequence.AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
5131  }
5132 }
5133 
5134 /// An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>,
5135 /// a function with a pointer return type contains a 'return false;' statement.
5136 /// In C++11, 'false' is not a null pointer, so this breaks the build of any
5137 /// code using that header.
5138 ///
5139 /// Work around this by treating 'return false;' as zero-initializing the result
5140 /// if it's used in a pointer-returning function in a system header.
5142  const InitializedEntity &Entity,
5143  const Expr *Init) {
5144  return S.getLangOpts().CPlusPlus11 &&
5145  Entity.getKind() == InitializedEntity::EK_Result &&
5146  Entity.getType()->isPointerType() &&
5147  isa<CXXBoolLiteralExpr>(Init) &&
5148  !cast<CXXBoolLiteralExpr>(Init)->getValue() &&
5150 }
5151 
5152 /// The non-zero enum values here are indexes into diagnostic alternatives.
5154 
5155 /// Determines whether this expression is an acceptable ICR source.
5157  bool isAddressOf, bool &isWeakAccess) {
5158  // Skip parens.
5159  e = e->IgnoreParens();
5160 
5161  // Skip address-of nodes.
5162  if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
5163  if (op->getOpcode() == UO_AddrOf)
5164  return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
5165  isWeakAccess);
5166 
5167  // Skip certain casts.
5168  } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
5169  switch (ce->getCastKind()) {
5170  case CK_Dependent:
5171  case CK_BitCast:
5172  case CK_LValueBitCast:
5173  case CK_NoOp:
5174  return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
5175 
5176  case CK_ArrayToPointerDecay:
5177  return IIK_nonscalar;
5178 
5179  case CK_NullToPointer:
5180  return IIK_okay;
5181 
5182  default:
5183  break;
5184  }
5185 
5186  // If we have a declaration reference, it had better be a local variable.
5187  } else if (isa<DeclRefExpr>(e)) {
5188  // set isWeakAccess to true, to mean that there will be an implicit
5189  // load which requires a cleanup.
5191  isWeakAccess = true;
5192 
5193  if (!isAddressOf) return IIK_nonlocal;
5194 
5195  VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
5196  if (!var) return IIK_nonlocal;
5197 
5198  return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
5199 
5200  // If we have a conditional operator, check both sides.
5201  } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
5202  if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
5203  isWeakAccess))
5204  return iik;
5205 
5206  return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
5207 
5208  // These are never scalar.
5209  } else if (isa<ArraySubscriptExpr>(e)) {
5210  return IIK_nonscalar;
5211 
5212  // Otherwise, it needs to be a null pointer constant.
5213  } else {
5215  ? IIK_okay : IIK_nonlocal);
5216  }
5217 
5218  return IIK_nonlocal;
5219 }
5220 
5221 /// Check whether the given expression is a valid operand for an
5222 /// indirect copy/restore.
5224  assert(src->isRValue());
5225  bool isWeakAccess = false;
5226  InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
5227  // If isWeakAccess to true, there will be an implicit
5228  // load which requires a cleanup.
5229  if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
5230  S.Cleanup.setExprNeedsCleanups(true);
5231 
5232  if (iik == IIK_okay) return;
5233 
5234  S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
5235  << ((unsigned) iik - 1) // shift index into diagnostic explanations
5236  << src->getSourceRange();
5237 }
5238 
5239 /// Determine whether we have compatible array types for the
5240 /// purposes of GNU by-copy array initialization.
5241 static bool hasCompatibleArrayTypes(ASTContext &Context, const ArrayType *Dest,
5242  const ArrayType *Source) {
5243  // If the source and destination array types are equivalent, we're
5244  // done.
5245  if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
5246  return true;
5247 
5248  // Make sure that the element types are the same.
5249  if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
5250  return false;
5251 
5252  // The only mismatch we allow is when the destination is an
5253  // incomplete array type and the source is a constant array type.
5254  return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
5255 }
5256 
5258  InitializationSequence &Sequence,
5259  const InitializedEntity &Entity,
5260  Expr *Initializer) {
5261  bool ArrayDecay = false;
5262  QualType ArgType = Initializer->getType();
5263  QualType ArgPointee;
5264  if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
5265  ArrayDecay = true;
5266  ArgPointee = ArgArrayType->getElementType();
5267  ArgType = S.Context.getPointerType(ArgPointee);
5268  }
5269 
5270  // Handle write-back conversion.
5271  QualType ConvertedArgType;
5272  if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
5273  ConvertedArgType))
5274  return false;
5275 
5276  // We should copy unless we're passing to an argument explicitly
5277  // marked 'out'.
5278  bool ShouldCopy = true;
5279  if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
5280  ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
5281 
5282  // Do we need an lvalue conversion?
5283  if (ArrayDecay || Initializer->isGLValue()) {
5285  ICS.setStandard();
5287 
5288  QualType ResultType;
5289  if (ArrayDecay) {
5291  ResultType = S.Context.getPointerType(ArgPointee);
5292  } else {
5294  ResultType = Initializer->getType().getNonLValueExprType(S.Context);
5295  }
5296 
5297  Sequence.AddConversionSequenceStep(ICS, ResultType);
5298  }
5299 
5300  Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
5301  return true;
5302 }
5303 
5305  InitializationSequence &Sequence,
5306  QualType DestType,
5307  Expr *Initializer) {
5308  if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
5309  (!Initializer->isIntegerConstantExpr(S.Context) &&
5310  !Initializer->getType()->isSamplerT()))
5311  return false;
5312 
5313  Sequence.AddOCLSamplerInitStep(DestType);
5314  return true;
5315 }
5316 
5317 static bool IsZeroInitializer(Expr *Initializer, Sema &S) {
5318  return Initializer->isIntegerConstantExpr(S.getASTContext()) &&
5319  (Initializer->EvaluateKnownConstInt(S.getASTContext()) == 0);
5320 }
5321 
5323  InitializationSequence &Sequence,
5324  QualType DestType,
5325  Expr *Initializer) {
5326  if (!S.getLangOpts().OpenCL)
5327  return false;
5328 
5329  //
5330  // OpenCL 1.2 spec, s6.12.10
5331  //
5332  // The event argument can also be used to associate the
5333  // async_work_group_copy with a previous async copy allowing
5334  // an event to be shared by multiple async copies; otherwise
5335  // event should be zero.
5336  //
5337  if (DestType->isEventT() || DestType->isQueueT()) {
5338  if (!IsZeroInitializer(Initializer, S))
5339  return false;
5340 
5341  Sequence.AddOCLZeroOpaqueTypeStep(DestType);
5342  return true;
5343  }
5344 
5345  // We should allow zero initialization for all types defined in the
5346  // cl_intel_device_side_avc_motion_estimation extension, except
5347  // intel_sub_group_avc_mce_payload_t and intel_sub_group_avc_mce_result_t.
5348  if (S.getOpenCLOptions().isEnabled(
5349  "cl_intel_device_side_avc_motion_estimation") &&
5350  DestType->isOCLIntelSubgroupAVCType()) {
5351  if (DestType->isOCLIntelSubgroupAVCMcePayloadType() ||
5352  DestType->isOCLIntelSubgroupAVCMceResultType())
5353  return false;
5354  if (!IsZeroInitializer(Initializer, S))
5355  return false;
5356 
5357  Sequence.AddOCLZeroOpaqueTypeStep(DestType);
5358  return true;
5359  }
5360 
5361  return false;
5362 }
5363 
5365  const InitializedEntity &Entity,
5366  const InitializationKind &Kind,
5367  MultiExprArg Args,
5368  bool TopLevelOfInitList,
5369  bool TreatUnavailableAsInvalid)
5370  : FailedCandidateSet(Kind.getLocation(), OverloadCandidateSet::CSK_Normal) {
5371  InitializeFrom(S, Entity, Kind, Args, TopLevelOfInitList,
5372  TreatUnavailableAsInvalid);
5373 }
5374 
5375 /// Tries to get a FunctionDecl out of `E`. If it succeeds and we can take the
5376 /// address of that function, this returns true. Otherwise, it returns false.
5377 static bool isExprAnUnaddressableFunction(Sema &S, const Expr *E) {
5378  auto *DRE = dyn_cast<DeclRefExpr>(E);
5379  if (!DRE || !isa<FunctionDecl>(DRE->getDecl()))
5380  return false;
5381 
5383  cast<FunctionDecl>(DRE->getDecl()));
5384 }
5385 
5386 /// Determine whether we can perform an elementwise array copy for this kind
5387 /// of entity.
5388 static bool canPerformArrayCopy(const InitializedEntity &Entity) {
5389  switch (Entity.getKind()) {
5391  // C++ [expr.prim.lambda]p24:
5392  // For array members, the array elements are direct-initialized in
5393  // increasing subscript order.
5394  return true;
5395 
5397  // C++ [dcl.decomp]p1:
5398  // [...] each element is copy-initialized or direct-initialized from the
5399  // corresponding element of the assignment-expression [...]
5400  return isa<DecompositionDecl>(Entity.getDecl());
5401 
5403  // C++ [class.copy.ctor]p14:
5404  // - if the member is an array, each element is direct-initialized with
5405  // the corresponding subobject of x
5406  return Entity.isImplicitMemberInitializer();
5407 
5409  // All the above cases are intended to apply recursively, even though none
5410  // of them actually say that.
5411  if (auto *E = Entity.getParent())
5412  return canPerformArrayCopy(*E);
5413  break;
5414 
5415  default:
5416  break;
5417  }
5418 
5419  return false;
5420 }
5421 
5423  const InitializedEntity &Entity,
5424  const InitializationKind &Kind,
5425  MultiExprArg Args,
5426  bool TopLevelOfInitList,
5427  bool TreatUnavailableAsInvalid) {
5428  ASTContext &Context = S.Context;
5429 
5430  // Eliminate non-overload placeholder types in the arguments. We
5431  // need to do this before checking whether types are dependent
5432  // because lowering a pseudo-object expression might well give us
5433  // something of dependent type.
5434  for (unsigned I = 0, E = Args.size(); I != E; ++I)
5435  if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
5436  // FIXME: should we be doing this here?
5437  ExprResult result = S.CheckPlaceholderExpr(Args[I]);
5438  if (result.isInvalid()) {
5440  return;
5441  }
5442  Args[I] = result.get();
5443  }
5444 
5445  // C++0x [dcl.init]p16:
5446  // The semantics of initializers are as follows. The destination type is
5447  // the type of the object or reference being initialized and the source
5448  // type is the type of the initializer expression. The source type is not
5449  // defined when the initializer is a braced-init-list or when it is a
5450  // parenthesized list of expressions.
5451  QualType DestType = Entity.getType();
5452 
5453  if (DestType->isDependentType() ||
5456  return;
5457  }
5458 
5459  // Almost everything is a normal sequence.
5461 
5462  QualType SourceType;
5463  Expr *Initializer = nullptr;
5464  if (Args.size() == 1) {
5465  Initializer = Args[0];
5466  if (S.getLangOpts().ObjC) {
5467  if (S.CheckObjCBridgeRelatedConversions(Initializer->getBeginLoc(),
5468  DestType, Initializer->getType(),
5469  Initializer) ||
5470  S.ConversionToObjCStringLiteralCheck(DestType, Initializer))
5471  Args[0] = Initializer;
5472  }
5473  if (!isa<InitListExpr>(Initializer))
5474  SourceType = Initializer->getType();
5475  }
5476 
5477  // - If the initializer is a (non-parenthesized) braced-init-list, the
5478  // object is list-initialized (8.5.4).
5479  if (Kind.getKind() != InitializationKind::IK_Direct) {
5480  if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
5481  TryListInitialization(S, Entity, Kind, InitList, *this,
5482  TreatUnavailableAsInvalid);
5483  return;
5484  }
5485  }
5486 
5487  // - If the destination type is a reference type, see 8.5.3.
5488  if (DestType->isReferenceType()) {
5489  // C++0x [dcl.init.ref]p1:
5490  // A variable declared to be a T& or T&&, that is, "reference to type T"
5491  // (8.3.2), shall be initialized by an object, or function, of type T or
5492  // by an object that can be converted into a T.
5493  // (Therefore, multiple arguments are not permitted.)
5494  if (Args.size() != 1)
5496  // C++17 [dcl.init.ref]p5:
5497  // A reference [...] is initialized by an expression [...] as follows:
5498  // If the initializer is not an expression, presumably we should reject,
5499  // but the standard fails to actually say so.
5500  else if (isa<InitListExpr>(Args[0]))
5502  else
5503  TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
5504  return;
5505  }
5506 
5507  // - If the initializer is (), the object is value-initialized.
5508  if (Kind.getKind() == InitializationKind::IK_Value ||
5509  (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
5510  TryValueInitialization(S, Entity, Kind, *this);
5511  return;
5512  }
5513 
5514  // Handle default initialization.
5515  if (Kind.getKind() == InitializationKind::IK_Default) {
5516  TryDefaultInitialization(S, Entity, Kind, *this);
5517  return;
5518  }
5519 
5520  // - If the destination type is an array of characters, an array of
5521  // char16_t, an array of char32_t, or an array of wchar_t, and the
5522  // initializer is a string literal, see 8.5.2.
5523  // - Otherwise, if the destination type is an array, the program is
5524  // ill-formed.
5525  if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
5526  if (Initializer && isa<VariableArrayType>(DestAT)) {
5528  return;
5529  }
5530 
5531  if (Initializer) {
5532  switch (IsStringInit(Initializer, DestAT, Context)) {
5533  case SIF_None:
5534  TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
5535  return;
5538  return;
5541  return;
5544  return;
5547  return;
5550  return;
5551  case SIF_Other:
5552  break;
5553  }
5554  }
5555 
5556  // Some kinds of initialization permit an array to be initialized from
5557  // another array of the same type, and perform elementwise initialization.
5558  if (Initializer && isa<ConstantArrayType>(DestAT) &&
5559  S.Context.hasSameUnqualifiedType(Initializer->getType(),
5560  Entity.getType()) &&
<