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