clang  3.7.0
SemaInit.cpp
Go to the documentation of this file.
1 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements semantic analysis for initializers.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclObjC.h"
17 #include "clang/AST/ExprCXX.h"
18 #include "clang/AST/ExprObjC.h"
19 #include "clang/AST/TypeLoc.h"
20 #include "clang/Basic/TargetInfo.h"
21 #include "clang/Sema/Designator.h"
22 #include "clang/Sema/Lookup.h"
24 #include "llvm/ADT/APInt.h"
25 #include "llvm/ADT/SmallString.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include <map>
29 using namespace clang;
30 
31 //===----------------------------------------------------------------------===//
32 // Sema Initialization Checking
33 //===----------------------------------------------------------------------===//
34 
35 /// \brief Check whether T is compatible with a wide character type (wchar_t,
36 /// char16_t or char32_t).
38  if (Context.typesAreCompatible(Context.getWideCharType(), T))
39  return true;
40  if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) {
41  return Context.typesAreCompatible(Context.Char16Ty, T) ||
42  Context.typesAreCompatible(Context.Char32Ty, T);
43  }
44  return false;
45 }
46 
53 };
54 
55 /// \brief Check whether the array of type AT can be initialized by the Init
56 /// expression by means of string initialization. Returns SIF_None if so,
57 /// otherwise returns a StringInitFailureKind that describes why the
58 /// initialization would not work.
61  if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
62  return SIF_Other;
63 
64  // See if this is a string literal or @encode.
65  Init = Init->IgnoreParens();
66 
67  // Handle @encode, which is a narrow string.
68  if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
69  return SIF_None;
70 
71  // Otherwise we can only handle string literals.
72  StringLiteral *SL = dyn_cast<StringLiteral>(Init);
73  if (!SL)
74  return SIF_Other;
75 
76  const QualType ElemTy =
77  Context.getCanonicalType(AT->getElementType()).getUnqualifiedType();
78 
79  switch (SL->getKind()) {
82  // char array can be initialized with a narrow string.
83  // Only allow char x[] = "foo"; not char x[] = L"foo";
84  if (ElemTy->isCharType())
85  return SIF_None;
86  if (IsWideCharCompatible(ElemTy, Context))
88  return SIF_Other;
89  // C99 6.7.8p15 (with correction from DR343), or C11 6.7.9p15:
90  // "An array with element type compatible with a qualified or unqualified
91  // version of wchar_t, char16_t, or char32_t may be initialized by a wide
92  // string literal with the corresponding encoding prefix (L, u, or U,
93  // respectively), optionally enclosed in braces.
95  if (Context.typesAreCompatible(Context.Char16Ty, ElemTy))
96  return SIF_None;
97  if (ElemTy->isCharType())
99  if (IsWideCharCompatible(ElemTy, Context))
101  return SIF_Other;
103  if (Context.typesAreCompatible(Context.Char32Ty, ElemTy))
104  return SIF_None;
105  if (ElemTy->isCharType())
106  return SIF_WideStringIntoChar;
107  if (IsWideCharCompatible(ElemTy, Context))
109  return SIF_Other;
110  case StringLiteral::Wide:
111  if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy))
112  return SIF_None;
113  if (ElemTy->isCharType())
114  return SIF_WideStringIntoChar;
115  if (IsWideCharCompatible(ElemTy, Context))
117  return SIF_Other;
118  }
119 
120  llvm_unreachable("missed a StringLiteral kind?");
121 }
122 
124  ASTContext &Context) {
125  const ArrayType *arrayType = Context.getAsArrayType(declType);
126  if (!arrayType)
127  return SIF_Other;
128  return IsStringInit(init, arrayType, Context);
129 }
130 
131 /// Update the type of a string literal, including any surrounding parentheses,
132 /// to match the type of the object which it is initializing.
133 static void updateStringLiteralType(Expr *E, QualType Ty) {
134  while (true) {
135  E->setType(Ty);
136  if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
137  break;
138  else if (ParenExpr *PE = dyn_cast<ParenExpr>(E))
139  E = PE->getSubExpr();
140  else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
141  E = UO->getSubExpr();
142  else if (GenericSelectionExpr *GSE = dyn_cast<GenericSelectionExpr>(E))
143  E = GSE->getResultExpr();
144  else
145  llvm_unreachable("unexpected expr in string literal init");
146  }
147 }
148 
149 static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,
150  Sema &S) {
151  // Get the length of the string as parsed.
152  auto *ConstantArrayTy =
153  cast<ConstantArrayType>(Str->getType()->getAsArrayTypeUnsafe());
154  uint64_t StrLength = ConstantArrayTy->getSize().getZExtValue();
155 
156  if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
157  // C99 6.7.8p14. We have an array of character type with unknown size
158  // being initialized to a string literal.
159  llvm::APInt ConstVal(32, StrLength);
160  // Return a new array type (C99 6.7.8p22).
161  DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
162  ConstVal,
163  ArrayType::Normal, 0);
164  updateStringLiteralType(Str, DeclT);
165  return;
166  }
167 
168  const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
169 
170  // We have an array of character type with known size. However,
171  // the size may be smaller or larger than the string we are initializing.
172  // FIXME: Avoid truncation for 64-bit length strings.
173  if (S.getLangOpts().CPlusPlus) {
174  if (StringLiteral *SL = dyn_cast<StringLiteral>(Str->IgnoreParens())) {
175  // For Pascal strings it's OK to strip off the terminating null character,
176  // so the example below is valid:
177  //
178  // unsigned char a[2] = "\pa";
179  if (SL->isPascal())
180  StrLength--;
181  }
182 
183  // [dcl.init.string]p2
184  if (StrLength > CAT->getSize().getZExtValue())
185  S.Diag(Str->getLocStart(),
186  diag::err_initializer_string_for_char_array_too_long)
187  << Str->getSourceRange();
188  } else {
189  // C99 6.7.8p14.
190  if (StrLength-1 > CAT->getSize().getZExtValue())
191  S.Diag(Str->getLocStart(),
192  diag::ext_initializer_string_for_char_array_too_long)
193  << Str->getSourceRange();
194  }
195 
196  // Set the type to the actual size that we are initializing. If we have
197  // something like:
198  // char x[1] = "foo";
199  // then this will set the string literal's type to char[1].
200  updateStringLiteralType(Str, DeclT);
201 }
202 
203 //===----------------------------------------------------------------------===//
204 // Semantic checking for initializer lists.
205 //===----------------------------------------------------------------------===//
206 
207 /// @brief Semantic checking for initializer lists.
208 ///
209 /// The InitListChecker class contains a set of routines that each
210 /// handle the initialization of a certain kind of entity, e.g.,
211 /// arrays, vectors, struct/union types, scalars, etc. The
212 /// InitListChecker itself performs a recursive walk of the subobject
213 /// structure of the type to be initialized, while stepping through
214 /// the initializer list one element at a time. The IList and Index
215 /// parameters to each of the Check* routines contain the active
216 /// (syntactic) initializer list and the index into that initializer
217 /// list that represents the current initializer. Each routine is
218 /// responsible for moving that Index forward as it consumes elements.
219 ///
220 /// Each Check* routine also has a StructuredList/StructuredIndex
221 /// arguments, which contains the current "structured" (semantic)
222 /// initializer list and the index into that initializer list where we
223 /// are copying initializers as we map them over to the semantic
224 /// list. Once we have completed our recursive walk of the subobject
225 /// structure, we will have constructed a full semantic initializer
226 /// list.
227 ///
228 /// C99 designators cause changes in the initializer list traversal,
229 /// because they make the initialization "jump" into a specific
230 /// subobject and then continue the initialization from that
231 /// point. CheckDesignatedInitializer() recursively steps into the
232 /// designated subobject and manages backing out the recursion to
233 /// initialize the subobjects after the one designated.
234 namespace {
235 class InitListChecker {
236  Sema &SemaRef;
237  bool hadError;
238  bool VerifyOnly; // no diagnostics, no structure building
239  llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic;
240  InitListExpr *FullyStructuredList;
241 
242  void CheckImplicitInitList(const InitializedEntity &Entity,
243  InitListExpr *ParentIList, QualType T,
244  unsigned &Index, InitListExpr *StructuredList,
245  unsigned &StructuredIndex);
246  void CheckExplicitInitList(const InitializedEntity &Entity,
247  InitListExpr *IList, QualType &T,
248  InitListExpr *StructuredList,
249  bool TopLevelObject = false);
250  void CheckListElementTypes(const InitializedEntity &Entity,
251  InitListExpr *IList, QualType &DeclType,
252  bool SubobjectIsDesignatorContext,
253  unsigned &Index,
254  InitListExpr *StructuredList,
255  unsigned &StructuredIndex,
256  bool TopLevelObject = false);
257  void CheckSubElementType(const InitializedEntity &Entity,
258  InitListExpr *IList, QualType ElemType,
259  unsigned &Index,
260  InitListExpr *StructuredList,
261  unsigned &StructuredIndex);
262  void CheckComplexType(const InitializedEntity &Entity,
263  InitListExpr *IList, QualType DeclType,
264  unsigned &Index,
265  InitListExpr *StructuredList,
266  unsigned &StructuredIndex);
267  void CheckScalarType(const InitializedEntity &Entity,
268  InitListExpr *IList, QualType DeclType,
269  unsigned &Index,
270  InitListExpr *StructuredList,
271  unsigned &StructuredIndex);
272  void CheckReferenceType(const InitializedEntity &Entity,
273  InitListExpr *IList, QualType DeclType,
274  unsigned &Index,
275  InitListExpr *StructuredList,
276  unsigned &StructuredIndex);
277  void CheckVectorType(const InitializedEntity &Entity,
278  InitListExpr *IList, QualType DeclType, unsigned &Index,
279  InitListExpr *StructuredList,
280  unsigned &StructuredIndex);
281  void CheckStructUnionTypes(const InitializedEntity &Entity,
282  InitListExpr *IList, QualType DeclType,
284  bool SubobjectIsDesignatorContext, unsigned &Index,
285  InitListExpr *StructuredList,
286  unsigned &StructuredIndex,
287  bool TopLevelObject = false);
288  void CheckArrayType(const InitializedEntity &Entity,
289  InitListExpr *IList, QualType &DeclType,
290  llvm::APSInt elementIndex,
291  bool SubobjectIsDesignatorContext, unsigned &Index,
292  InitListExpr *StructuredList,
293  unsigned &StructuredIndex);
294  bool CheckDesignatedInitializer(const InitializedEntity &Entity,
295  InitListExpr *IList, DesignatedInitExpr *DIE,
296  unsigned DesigIdx,
297  QualType &CurrentObjectType,
298  RecordDecl::field_iterator *NextField,
299  llvm::APSInt *NextElementIndex,
300  unsigned &Index,
301  InitListExpr *StructuredList,
302  unsigned &StructuredIndex,
303  bool FinishSubobjectInit,
304  bool TopLevelObject);
305  InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
306  QualType CurrentObjectType,
307  InitListExpr *StructuredList,
308  unsigned StructuredIndex,
309  SourceRange InitRange,
310  bool IsFullyOverwritten = false);
311  void UpdateStructuredListElement(InitListExpr *StructuredList,
312  unsigned &StructuredIndex,
313  Expr *expr);
314  int numArrayElements(QualType DeclType);
315  int numStructUnionElements(QualType DeclType);
316 
317  static ExprResult PerformEmptyInit(Sema &SemaRef,
318  SourceLocation Loc,
319  const InitializedEntity &Entity,
320  bool VerifyOnly);
321 
322  // Explanation on the "FillWithNoInit" mode:
323  //
324  // Assume we have the following definitions (Case#1):
325  // struct P { char x[6][6]; } xp = { .x[1] = "bar" };
326  // struct PP { struct P lp; } l = { .lp = xp, .lp.x[1][2] = 'f' };
327  //
328  // l.lp.x[1][0..1] should not be filled with implicit initializers because the
329  // "base" initializer "xp" will provide values for them; l.lp.x[1] will be "baf".
330  //
331  // But if we have (Case#2):
332  // struct PP l = { .lp = xp, .lp.x[1] = { [2] = 'f' } };
333  //
334  // l.lp.x[1][0..1] are implicitly initialized and do not use values from the
335  // "base" initializer; l.lp.x[1] will be "\0\0f\0\0\0".
336  //
337  // To distinguish Case#1 from Case#2, and also to avoid leaving many "holes"
338  // in the InitListExpr, the "holes" in Case#1 are filled not with empty
339  // initializers but with special "NoInitExpr" place holders, which tells the
340  // CodeGen not to generate any initializers for these parts.
341  void FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
342  const InitializedEntity &ParentEntity,
343  InitListExpr *ILE, bool &RequiresSecondPass,
344  bool FillWithNoInit = false);
345  void FillInEmptyInitializations(const InitializedEntity &Entity,
346  InitListExpr *ILE, bool &RequiresSecondPass,
347  bool FillWithNoInit = false);
348  bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
349  Expr *InitExpr, FieldDecl *Field,
350  bool TopLevelObject);
351  void CheckEmptyInitializable(const InitializedEntity &Entity,
352  SourceLocation Loc);
353 
354 public:
355  InitListChecker(Sema &S, const InitializedEntity &Entity,
356  InitListExpr *IL, QualType &T, bool VerifyOnly);
357  bool HadError() { return hadError; }
358 
359  // @brief Retrieves the fully-structured initializer list used for
360  // semantic analysis and code generation.
361  InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
362 };
363 } // end anonymous namespace
364 
365 ExprResult InitListChecker::PerformEmptyInit(Sema &SemaRef,
366  SourceLocation Loc,
367  const InitializedEntity &Entity,
368  bool VerifyOnly) {
370  true);
371  MultiExprArg SubInit;
372  Expr *InitExpr;
373  InitListExpr DummyInitList(SemaRef.Context, Loc, None, Loc);
374 
375  // C++ [dcl.init.aggr]p7:
376  // If there are fewer initializer-clauses in the list than there are
377  // members in the aggregate, then each member not explicitly initialized
378  // ...
379  bool EmptyInitList = SemaRef.getLangOpts().CPlusPlus11 &&
381  if (EmptyInitList) {
382  // C++1y / DR1070:
383  // shall be initialized [...] from an empty initializer list.
384  //
385  // We apply the resolution of this DR to C++11 but not C++98, since C++98
386  // does not have useful semantics for initialization from an init list.
387  // We treat this as copy-initialization, because aggregate initialization
388  // always performs copy-initialization on its elements.
389  //
390  // Only do this if we're initializing a class type, to avoid filling in
391  // the initializer list where possible.
392  InitExpr = VerifyOnly ? &DummyInitList : new (SemaRef.Context)
393  InitListExpr(SemaRef.Context, Loc, None, Loc);
394  InitExpr->setType(SemaRef.Context.VoidTy);
395  SubInit = InitExpr;
396  Kind = InitializationKind::CreateCopy(Loc, Loc);
397  } else {
398  // C++03:
399  // shall be value-initialized.
400  }
401 
402  InitializationSequence InitSeq(SemaRef, Entity, Kind, SubInit);
403  // libstdc++4.6 marks the vector default constructor as explicit in
404  // _GLIBCXX_DEBUG mode, so recover using the C++03 logic in that case.
405  // stlport does so too. Look for std::__debug for libstdc++, and for
406  // std:: for stlport. This is effectively a compiler-side implementation of
407  // LWG2193.
408  if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
412  InitSeq.getFailedCandidateSet()
413  .BestViableFunction(SemaRef, Kind.getLocation(), Best);
414  (void)O;
415  assert(O == OR_Success && "Inconsistent overload resolution");
416  CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
417  CXXRecordDecl *R = CtorDecl->getParent();
418 
419  if (CtorDecl->getMinRequiredArguments() == 0 &&
420  CtorDecl->isExplicit() && R->getDeclName() &&
421  SemaRef.SourceMgr.isInSystemHeader(CtorDecl->getLocation())) {
422 
423 
424  bool IsInStd = false;
425  for (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(R->getDeclContext());
426  ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
427  if (SemaRef.getStdNamespace()->InEnclosingNamespaceSetOf(ND))
428  IsInStd = true;
429  }
430 
431  if (IsInStd && llvm::StringSwitch<bool>(R->getName())
432  .Cases("basic_string", "deque", "forward_list", true)
433  .Cases("list", "map", "multimap", "multiset", true)
434  .Cases("priority_queue", "queue", "set", "stack", true)
435  .Cases("unordered_map", "unordered_set", "vector", true)
436  .Default(false)) {
437  InitSeq.InitializeFrom(
438  SemaRef, Entity,
439  InitializationKind::CreateValue(Loc, Loc, Loc, true),
440  MultiExprArg(), /*TopLevelOfInitList=*/false);
441  // Emit a warning for this. System header warnings aren't shown
442  // by default, but people working on system headers should see it.
443  if (!VerifyOnly) {
444  SemaRef.Diag(CtorDecl->getLocation(),
445  diag::warn_invalid_initializer_from_system_header);
446  SemaRef.Diag(Entity.getDecl()->getLocation(),
447  diag::note_used_in_initialization_here);
448  }
449  }
450  }
451  }
452  if (!InitSeq) {
453  if (!VerifyOnly) {
454  InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
455  if (Entity.getKind() == InitializedEntity::EK_Member)
456  SemaRef.Diag(Entity.getDecl()->getLocation(),
457  diag::note_in_omitted_aggregate_initializer)
458  << /*field*/1 << Entity.getDecl();
459  else if (Entity.getKind() == InitializedEntity::EK_ArrayElement)
460  SemaRef.Diag(Loc, diag::note_in_omitted_aggregate_initializer)
461  << /*array element*/0 << Entity.getElementIndex();
462  }
463  return ExprError();
464  }
465 
466  return VerifyOnly ? ExprResult(static_cast<Expr *>(nullptr))
467  : InitSeq.Perform(SemaRef, Entity, Kind, SubInit);
468 }
469 
470 void InitListChecker::CheckEmptyInitializable(const InitializedEntity &Entity,
471  SourceLocation Loc) {
472  assert(VerifyOnly &&
473  "CheckEmptyInitializable is only inteded for verification mode.");
474  if (PerformEmptyInit(SemaRef, Loc, Entity, /*VerifyOnly*/true).isInvalid())
475  hadError = true;
476 }
477 
478 void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
479  const InitializedEntity &ParentEntity,
480  InitListExpr *ILE,
481  bool &RequiresSecondPass,
482  bool FillWithNoInit) {
483  SourceLocation Loc = ILE->getLocEnd();
484  unsigned NumInits = ILE->getNumInits();
485  InitializedEntity MemberEntity
486  = InitializedEntity::InitializeMember(Field, &ParentEntity);
487 
488  if (const RecordType *RType = ILE->getType()->getAs<RecordType>())
489  if (!RType->getDecl()->isUnion())
490  assert(Init < NumInits && "This ILE should have been expanded");
491 
492  if (Init >= NumInits || !ILE->getInit(Init)) {
493  if (FillWithNoInit) {
494  Expr *Filler = new (SemaRef.Context) NoInitExpr(Field->getType());
495  if (Init < NumInits)
496  ILE->setInit(Init, Filler);
497  else
498  ILE->updateInit(SemaRef.Context, Init, Filler);
499  return;
500  }
501  // C++1y [dcl.init.aggr]p7:
502  // If there are fewer initializer-clauses in the list than there are
503  // members in the aggregate, then each member not explicitly initialized
504  // shall be initialized from its brace-or-equal-initializer [...]
505  if (Field->hasInClassInitializer()) {
506  ExprResult DIE = SemaRef.BuildCXXDefaultInitExpr(Loc, Field);
507  if (DIE.isInvalid()) {
508  hadError = true;
509  return;
510  }
511  if (Init < NumInits)
512  ILE->setInit(Init, DIE.get());
513  else {
514  ILE->updateInit(SemaRef.Context, Init, DIE.get());
515  RequiresSecondPass = true;
516  }
517  return;
518  }
519 
520  if (Field->getType()->isReferenceType()) {
521  // C++ [dcl.init.aggr]p9:
522  // If an incomplete or empty initializer-list leaves a
523  // member of reference type uninitialized, the program is
524  // ill-formed.
525  SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
526  << Field->getType()
527  << ILE->getSyntacticForm()->getSourceRange();
528  SemaRef.Diag(Field->getLocation(),
529  diag::note_uninit_reference_member);
530  hadError = true;
531  return;
532  }
533 
534  ExprResult MemberInit = PerformEmptyInit(SemaRef, Loc, MemberEntity,
535  /*VerifyOnly*/false);
536  if (MemberInit.isInvalid()) {
537  hadError = true;
538  return;
539  }
540 
541  if (hadError) {
542  // Do nothing
543  } else if (Init < NumInits) {
544  ILE->setInit(Init, MemberInit.getAs<Expr>());
545  } else if (!isa<ImplicitValueInitExpr>(MemberInit.get())) {
546  // Empty initialization requires a constructor call, so
547  // extend the initializer list to include the constructor
548  // call and make a note that we'll need to take another pass
549  // through the initializer list.
550  ILE->updateInit(SemaRef.Context, Init, MemberInit.getAs<Expr>());
551  RequiresSecondPass = true;
552  }
553  } else if (InitListExpr *InnerILE
554  = dyn_cast<InitListExpr>(ILE->getInit(Init)))
555  FillInEmptyInitializations(MemberEntity, InnerILE,
556  RequiresSecondPass, FillWithNoInit);
557  else if (DesignatedInitUpdateExpr *InnerDIUE
558  = dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init)))
559  FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
560  RequiresSecondPass, /*FillWithNoInit =*/ true);
561 }
562 
563 /// Recursively replaces NULL values within the given initializer list
564 /// with expressions that perform value-initialization of the
565 /// appropriate type.
566 void
567 InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity,
568  InitListExpr *ILE,
569  bool &RequiresSecondPass,
570  bool FillWithNoInit) {
571  assert((ILE->getType() != SemaRef.Context.VoidTy) &&
572  "Should not have void type");
573 
574  if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
575  const RecordDecl *RDecl = RType->getDecl();
576  if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())
577  FillInEmptyInitForField(0, ILE->getInitializedFieldInUnion(),
578  Entity, ILE, RequiresSecondPass, FillWithNoInit);
579  else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
580  cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
581  for (auto *Field : RDecl->fields()) {
582  if (Field->hasInClassInitializer()) {
583  FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass,
584  FillWithNoInit);
585  break;
586  }
587  }
588  } else {
589  // The fields beyond ILE->getNumInits() are default initialized, so in
590  // order to leave them uninitialized, the ILE is expanded and the extra
591  // fields are then filled with NoInitExpr.
592  unsigned NumFields = 0;
593  for (auto *Field : RDecl->fields())
594  if (!Field->isUnnamedBitfield())
595  ++NumFields;
596  if (ILE->getNumInits() < NumFields)
597  ILE->resizeInits(SemaRef.Context, NumFields);
598 
599  unsigned Init = 0;
600  for (auto *Field : RDecl->fields()) {
601  if (Field->isUnnamedBitfield())
602  continue;
603 
604  if (hadError)
605  return;
606 
607  FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass,
608  FillWithNoInit);
609  if (hadError)
610  return;
611 
612  ++Init;
613 
614  // Only look at the first initialization of a union.
615  if (RDecl->isUnion())
616  break;
617  }
618  }
619 
620  return;
621  }
622 
623  QualType ElementType;
624 
625  InitializedEntity ElementEntity = Entity;
626  unsigned NumInits = ILE->getNumInits();
627  unsigned NumElements = NumInits;
628  if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
629  ElementType = AType->getElementType();
630  if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
631  NumElements = CAType->getSize().getZExtValue();
632  ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
633  0, Entity);
634  } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
635  ElementType = VType->getElementType();
636  NumElements = VType->getNumElements();
637  ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
638  0, Entity);
639  } else
640  ElementType = ILE->getType();
641 
642  for (unsigned Init = 0; Init != NumElements; ++Init) {
643  if (hadError)
644  return;
645 
646  if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
647  ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
648  ElementEntity.setElementIndex(Init);
649 
650  Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr);
651  if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
652  ILE->setInit(Init, ILE->getArrayFiller());
653  else if (!InitExpr && !ILE->hasArrayFiller()) {
654  Expr *Filler = nullptr;
655 
656  if (FillWithNoInit)
657  Filler = new (SemaRef.Context) NoInitExpr(ElementType);
658  else {
659  ExprResult ElementInit = PerformEmptyInit(SemaRef, ILE->getLocEnd(),
660  ElementEntity,
661  /*VerifyOnly*/false);
662  if (ElementInit.isInvalid()) {
663  hadError = true;
664  return;
665  }
666 
667  Filler = ElementInit.getAs<Expr>();
668  }
669 
670  if (hadError) {
671  // Do nothing
672  } else if (Init < NumInits) {
673  // For arrays, just set the expression used for value-initialization
674  // of the "holes" in the array.
675  if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
676  ILE->setArrayFiller(Filler);
677  else
678  ILE->setInit(Init, Filler);
679  } else {
680  // For arrays, just set the expression used for value-initialization
681  // of the rest of elements and exit.
682  if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
683  ILE->setArrayFiller(Filler);
684  return;
685  }
686 
687  if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {
688  // Empty initialization requires a constructor call, so
689  // extend the initializer list to include the constructor
690  // call and make a note that we'll need to take another pass
691  // through the initializer list.
692  ILE->updateInit(SemaRef.Context, Init, Filler);
693  RequiresSecondPass = true;
694  }
695  }
696  } else if (InitListExpr *InnerILE
697  = dyn_cast_or_null<InitListExpr>(InitExpr))
698  FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
699  FillWithNoInit);
700  else if (DesignatedInitUpdateExpr *InnerDIUE
701  = dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr))
702  FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
703  RequiresSecondPass, /*FillWithNoInit =*/ true);
704  }
705 }
706 
707 
708 InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
709  InitListExpr *IL, QualType &T,
710  bool VerifyOnly)
711  : SemaRef(S), VerifyOnly(VerifyOnly) {
712  // FIXME: Check that IL isn't already the semantic form of some other
713  // InitListExpr. If it is, we'd create a broken AST.
714 
715  hadError = false;
716 
717  FullyStructuredList =
718  getStructuredSubobjectInit(IL, 0, T, nullptr, 0, IL->getSourceRange());
719  CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
720  /*TopLevelObject=*/true);
721 
722  if (!hadError && !VerifyOnly) {
723  bool RequiresSecondPass = false;
724  FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass);
725  if (RequiresSecondPass && !hadError)
726  FillInEmptyInitializations(Entity, FullyStructuredList,
727  RequiresSecondPass);
728  }
729 }
730 
731 int InitListChecker::numArrayElements(QualType DeclType) {
732  // FIXME: use a proper constant
733  int maxElements = 0x7FFFFFFF;
734  if (const ConstantArrayType *CAT =
735  SemaRef.Context.getAsConstantArrayType(DeclType)) {
736  maxElements = static_cast<int>(CAT->getSize().getZExtValue());
737  }
738  return maxElements;
739 }
740 
741 int InitListChecker::numStructUnionElements(QualType DeclType) {
742  RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
743  int InitializableMembers = 0;
744  for (const auto *Field : structDecl->fields())
745  if (!Field->isUnnamedBitfield())
746  ++InitializableMembers;
747 
748  if (structDecl->isUnion())
749  return std::min(InitializableMembers, 1);
750  return InitializableMembers - structDecl->hasFlexibleArrayMember();
751 }
752 
753 /// Check whether the range of the initializer \p ParentIList from element
754 /// \p Index onwards can be used to initialize an object of type \p T. Update
755 /// \p Index to indicate how many elements of the list were consumed.
756 ///
757 /// This also fills in \p StructuredList, from element \p StructuredIndex
758 /// onwards, with the fully-braced, desugared form of the initialization.
759 void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
760  InitListExpr *ParentIList,
761  QualType T, unsigned &Index,
762  InitListExpr *StructuredList,
763  unsigned &StructuredIndex) {
764  int maxElements = 0;
765 
766  if (T->isArrayType())
767  maxElements = numArrayElements(T);
768  else if (T->isRecordType())
769  maxElements = numStructUnionElements(T);
770  else if (T->isVectorType())
771  maxElements = T->getAs<VectorType>()->getNumElements();
772  else
773  llvm_unreachable("CheckImplicitInitList(): Illegal type");
774 
775  if (maxElements == 0) {
776  if (!VerifyOnly)
777  SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
778  diag::err_implicit_empty_initializer);
779  ++Index;
780  hadError = true;
781  return;
782  }
783 
784  // Build a structured initializer list corresponding to this subobject.
785  InitListExpr *StructuredSubobjectInitList
786  = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
787  StructuredIndex,
788  SourceRange(ParentIList->getInit(Index)->getLocStart(),
789  ParentIList->getSourceRange().getEnd()));
790  unsigned StructuredSubobjectInitIndex = 0;
791 
792  // Check the element types and build the structural subobject.
793  unsigned StartIndex = Index;
794  CheckListElementTypes(Entity, ParentIList, T,
795  /*SubobjectIsDesignatorContext=*/false, Index,
796  StructuredSubobjectInitList,
797  StructuredSubobjectInitIndex);
798 
799  if (!VerifyOnly) {
800  StructuredSubobjectInitList->setType(T);
801 
802  unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
803  // Update the structured sub-object initializer so that it's ending
804  // range corresponds with the end of the last initializer it used.
805  if (EndIndex < ParentIList->getNumInits()) {
806  SourceLocation EndLoc
807  = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
808  StructuredSubobjectInitList->setRBraceLoc(EndLoc);
809  }
810 
811  // Complain about missing braces.
812  if (T->isArrayType() || T->isRecordType()) {
813  SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
814  diag::warn_missing_braces)
815  << StructuredSubobjectInitList->getSourceRange()
816  << FixItHint::CreateInsertion(
817  StructuredSubobjectInitList->getLocStart(), "{")
818  << FixItHint::CreateInsertion(
819  SemaRef.getLocForEndOfToken(
820  StructuredSubobjectInitList->getLocEnd()),
821  "}");
822  }
823  }
824 }
825 
826 /// Warn that \p Entity was of scalar type and was initialized by a
827 /// single-element braced initializer list.
828 static void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity,
829  SourceRange Braces) {
830  // Don't warn during template instantiation. If the initialization was
831  // non-dependent, we warned during the initial parse; otherwise, the
832  // type might not be scalar in some uses of the template.
833  if (!S.ActiveTemplateInstantiations.empty())
834  return;
835 
836  unsigned DiagID = 0;
837 
838  switch (Entity.getKind()) {
839  case InitializedEntity::EK_VectorElement:
840  case InitializedEntity::EK_ComplexElement:
841  case InitializedEntity::EK_ArrayElement:
842  case InitializedEntity::EK_Parameter:
843  case InitializedEntity::EK_Parameter_CF_Audited:
844  case InitializedEntity::EK_Result:
845  // Extra braces here are suspicious.
846  DiagID = diag::warn_braces_around_scalar_init;
847  break;
848 
849  case InitializedEntity::EK_Member:
850  // Warn on aggregate initialization but not on ctor init list or
851  // default member initializer.
852  if (Entity.getParent())
853  DiagID = diag::warn_braces_around_scalar_init;
854  break;
855 
856  case InitializedEntity::EK_Variable:
857  case InitializedEntity::EK_LambdaCapture:
858  // No warning, might be direct-list-initialization.
859  // FIXME: Should we warn for copy-list-initialization in these cases?
860  break;
861 
862  case InitializedEntity::EK_New:
863  case InitializedEntity::EK_Temporary:
864  case InitializedEntity::EK_CompoundLiteralInit:
865  // No warning, braces are part of the syntax of the underlying construct.
866  break;
867 
868  case InitializedEntity::EK_RelatedResult:
869  // No warning, we already warned when initializing the result.
870  break;
871 
872  case InitializedEntity::EK_Exception:
873  case InitializedEntity::EK_Base:
874  case InitializedEntity::EK_Delegating:
875  case InitializedEntity::EK_BlockElement:
876  llvm_unreachable("unexpected braced scalar init");
877  }
878 
879  if (DiagID) {
880  S.Diag(Braces.getBegin(), DiagID)
881  << Braces
882  << FixItHint::CreateRemoval(Braces.getBegin())
883  << FixItHint::CreateRemoval(Braces.getEnd());
884  }
885 }
886 
887 
888 /// Check whether the initializer \p IList (that was written with explicit
889 /// braces) can be used to initialize an object of type \p T.
890 ///
891 /// This also fills in \p StructuredList with the fully-braced, desugared
892 /// form of the initialization.
893 void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
894  InitListExpr *IList, QualType &T,
895  InitListExpr *StructuredList,
896  bool TopLevelObject) {
897  if (!VerifyOnly) {
898  SyntacticToSemantic[IList] = StructuredList;
899  StructuredList->setSyntacticForm(IList);
900  }
901 
902  unsigned Index = 0, StructuredIndex = 0;
903  CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
904  Index, StructuredList, StructuredIndex, TopLevelObject);
905  if (!VerifyOnly) {
906  QualType ExprTy = T;
907  if (!ExprTy->isArrayType())
908  ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context);
909  IList->setType(ExprTy);
910  StructuredList->setType(ExprTy);
911  }
912  if (hadError)
913  return;
914 
915  if (Index < IList->getNumInits()) {
916  // We have leftover initializers
917  if (VerifyOnly) {
918  if (SemaRef.getLangOpts().CPlusPlus ||
919  (SemaRef.getLangOpts().OpenCL &&
920  IList->getType()->isVectorType())) {
921  hadError = true;
922  }
923  return;
924  }
925 
926  if (StructuredIndex == 1 &&
927  IsStringInit(StructuredList->getInit(0), T, SemaRef.Context) ==
928  SIF_None) {
929  unsigned DK = diag::ext_excess_initializers_in_char_array_initializer;
930  if (SemaRef.getLangOpts().CPlusPlus) {
931  DK = diag::err_excess_initializers_in_char_array_initializer;
932  hadError = true;
933  }
934  // Special-case
935  SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
936  << IList->getInit(Index)->getSourceRange();
937  } else if (!T->isIncompleteType()) {
938  // Don't complain for incomplete types, since we'll get an error
939  // elsewhere
940  QualType CurrentObjectType = StructuredList->getType();
941  int initKind =
942  CurrentObjectType->isArrayType()? 0 :
943  CurrentObjectType->isVectorType()? 1 :
944  CurrentObjectType->isScalarType()? 2 :
945  CurrentObjectType->isUnionType()? 3 :
946  4;
947 
948  unsigned DK = diag::ext_excess_initializers;
949  if (SemaRef.getLangOpts().CPlusPlus) {
950  DK = diag::err_excess_initializers;
951  hadError = true;
952  }
953  if (SemaRef.getLangOpts().OpenCL && initKind == 1) {
954  DK = diag::err_excess_initializers;
955  hadError = true;
956  }
957 
958  SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
959  << initKind << IList->getInit(Index)->getSourceRange();
960  }
961  }
962 
963  if (!VerifyOnly && T->isScalarType() &&
964  IList->getNumInits() == 1 && !isa<InitListExpr>(IList->getInit(0)))
965  warnBracedScalarInit(SemaRef, Entity, IList->getSourceRange());
966 }
967 
968 void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
969  InitListExpr *IList,
970  QualType &DeclType,
971  bool SubobjectIsDesignatorContext,
972  unsigned &Index,
973  InitListExpr *StructuredList,
974  unsigned &StructuredIndex,
975  bool TopLevelObject) {
976  if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
977  // Explicitly braced initializer for complex type can be real+imaginary
978  // parts.
979  CheckComplexType(Entity, IList, DeclType, Index,
980  StructuredList, StructuredIndex);
981  } else if (DeclType->isScalarType()) {
982  CheckScalarType(Entity, IList, DeclType, Index,
983  StructuredList, StructuredIndex);
984  } else if (DeclType->isVectorType()) {
985  CheckVectorType(Entity, IList, DeclType, Index,
986  StructuredList, StructuredIndex);
987  } else if (DeclType->isRecordType()) {
988  assert(DeclType->isAggregateType() &&
989  "non-aggregate records should be handed in CheckSubElementType");
990  RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
991  CheckStructUnionTypes(Entity, IList, DeclType, RD->field_begin(),
992  SubobjectIsDesignatorContext, Index,
993  StructuredList, StructuredIndex,
994  TopLevelObject);
995  } else if (DeclType->isArrayType()) {
996  llvm::APSInt Zero(
997  SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
998  false);
999  CheckArrayType(Entity, IList, DeclType, Zero,
1000  SubobjectIsDesignatorContext, Index,
1001  StructuredList, StructuredIndex);
1002  } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
1003  // This type is invalid, issue a diagnostic.
1004  ++Index;
1005  if (!VerifyOnly)
1006  SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
1007  << DeclType;
1008  hadError = true;
1009  } else if (DeclType->isReferenceType()) {
1010  CheckReferenceType(Entity, IList, DeclType, Index,
1011  StructuredList, StructuredIndex);
1012  } else if (DeclType->isObjCObjectType()) {
1013  if (!VerifyOnly)
1014  SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
1015  << DeclType;
1016  hadError = true;
1017  } else {
1018  if (!VerifyOnly)
1019  SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
1020  << DeclType;
1021  hadError = true;
1022  }
1023 }
1024 
1025 void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
1026  InitListExpr *IList,
1027  QualType ElemType,
1028  unsigned &Index,
1029  InitListExpr *StructuredList,
1030  unsigned &StructuredIndex) {
1031  Expr *expr = IList->getInit(Index);
1032 
1033  if (ElemType->isReferenceType())
1034  return CheckReferenceType(Entity, IList, ElemType, Index,
1035  StructuredList, StructuredIndex);
1036 
1037  if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
1038  if (SubInitList->getNumInits() == 1 &&
1039  IsStringInit(SubInitList->getInit(0), ElemType, SemaRef.Context) ==
1040  SIF_None) {
1041  expr = SubInitList->getInit(0);
1042  } else if (!SemaRef.getLangOpts().CPlusPlus) {
1043  InitListExpr *InnerStructuredList
1044  = getStructuredSubobjectInit(IList, Index, ElemType,
1045  StructuredList, StructuredIndex,
1046  SubInitList->getSourceRange(), true);
1047  CheckExplicitInitList(Entity, SubInitList, ElemType,
1048  InnerStructuredList);
1049 
1050  if (!hadError && !VerifyOnly) {
1051  bool RequiresSecondPass = false;
1052  FillInEmptyInitializations(Entity, InnerStructuredList,
1053  RequiresSecondPass);
1054  if (RequiresSecondPass && !hadError)
1055  FillInEmptyInitializations(Entity, InnerStructuredList,
1056  RequiresSecondPass);
1057  }
1058  ++StructuredIndex;
1059  ++Index;
1060  return;
1061  }
1062  // C++ initialization is handled later.
1063  } else if (isa<ImplicitValueInitExpr>(expr)) {
1064  // This happens during template instantiation when we see an InitListExpr
1065  // that we've already checked once.
1066  assert(SemaRef.Context.hasSameType(expr->getType(), ElemType) &&
1067  "found implicit initialization for the wrong type");
1068  if (!VerifyOnly)
1069  UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1070  ++Index;
1071  return;
1072  }
1073 
1074  if (SemaRef.getLangOpts().CPlusPlus) {
1075  // C++ [dcl.init.aggr]p2:
1076  // Each member is copy-initialized from the corresponding
1077  // initializer-clause.
1078 
1079  // FIXME: Better EqualLoc?
1080  InitializationKind Kind =
1081  InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
1082  InitializationSequence Seq(SemaRef, Entity, Kind, expr,
1083  /*TopLevelOfInitList*/ true);
1084 
1085  // C++14 [dcl.init.aggr]p13:
1086  // If the assignment-expression can initialize a member, the member is
1087  // initialized. Otherwise [...] brace elision is assumed
1088  //
1089  // Brace elision is never performed if the element is not an
1090  // assignment-expression.
1091  if (Seq || isa<InitListExpr>(expr)) {
1092  if (!VerifyOnly) {
1093  ExprResult Result =
1094  Seq.Perform(SemaRef, Entity, Kind, expr);
1095  if (Result.isInvalid())
1096  hadError = true;
1097 
1098  UpdateStructuredListElement(StructuredList, StructuredIndex,
1099  Result.getAs<Expr>());
1100  } else if (!Seq)
1101  hadError = true;
1102  ++Index;
1103  return;
1104  }
1105 
1106  // Fall through for subaggregate initialization
1107  } else if (ElemType->isScalarType() || ElemType->isAtomicType()) {
1108  // FIXME: Need to handle atomic aggregate types with implicit init lists.
1109  return CheckScalarType(Entity, IList, ElemType, Index,
1110  StructuredList, StructuredIndex);
1111  } else if (const ArrayType *arrayType =
1112  SemaRef.Context.getAsArrayType(ElemType)) {
1113  // arrayType can be incomplete if we're initializing a flexible
1114  // array member. There's nothing we can do with the completed
1115  // type here, though.
1116 
1117  if (IsStringInit(expr, arrayType, SemaRef.Context) == SIF_None) {
1118  if (!VerifyOnly) {
1119  CheckStringInit(expr, ElemType, arrayType, SemaRef);
1120  UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1121  }
1122  ++Index;
1123  return;
1124  }
1125 
1126  // Fall through for subaggregate initialization.
1127 
1128  } else {
1129  assert((ElemType->isRecordType() || ElemType->isVectorType()) &&
1130  "Unexpected type");
1131 
1132  // C99 6.7.8p13:
1133  //
1134  // The initializer for a structure or union object that has
1135  // automatic storage duration shall be either an initializer
1136  // list as described below, or a single expression that has
1137  // compatible structure or union type. In the latter case, the
1138  // initial value of the object, including unnamed members, is
1139  // that of the expression.
1140  ExprResult ExprRes = expr;
1142  ElemType, ExprRes, !VerifyOnly) != Sema::Incompatible) {
1143  if (ExprRes.isInvalid())
1144  hadError = true;
1145  else {
1146  ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.get());
1147  if (ExprRes.isInvalid())
1148  hadError = true;
1149  }
1150  UpdateStructuredListElement(StructuredList, StructuredIndex,
1151  ExprRes.getAs<Expr>());
1152  ++Index;
1153  return;
1154  }
1155  ExprRes.get();
1156  // Fall through for subaggregate initialization
1157  }
1158 
1159  // C++ [dcl.init.aggr]p12:
1160  //
1161  // [...] Otherwise, if the member is itself a non-empty
1162  // subaggregate, brace elision is assumed and the initializer is
1163  // considered for the initialization of the first member of
1164  // the subaggregate.
1165  if (!SemaRef.getLangOpts().OpenCL &&
1166  (ElemType->isAggregateType() || ElemType->isVectorType())) {
1167  CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
1168  StructuredIndex);
1169  ++StructuredIndex;
1170  } else {
1171  if (!VerifyOnly) {
1172  // We cannot initialize this element, so let
1173  // PerformCopyInitialization produce the appropriate diagnostic.
1174  SemaRef.PerformCopyInitialization(Entity, SourceLocation(), expr,
1175  /*TopLevelOfInitList=*/true);
1176  }
1177  hadError = true;
1178  ++Index;
1179  ++StructuredIndex;
1180  }
1181 }
1182 
1183 void InitListChecker::CheckComplexType(const InitializedEntity &Entity,
1184  InitListExpr *IList, QualType DeclType,
1185  unsigned &Index,
1186  InitListExpr *StructuredList,
1187  unsigned &StructuredIndex) {
1188  assert(Index == 0 && "Index in explicit init list must be zero");
1189 
1190  // As an extension, clang supports complex initializers, which initialize
1191  // a complex number component-wise. When an explicit initializer list for
1192  // a complex number contains two two initializers, this extension kicks in:
1193  // it exepcts the initializer list to contain two elements convertible to
1194  // the element type of the complex type. The first element initializes
1195  // the real part, and the second element intitializes the imaginary part.
1196 
1197  if (IList->getNumInits() != 2)
1198  return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1199  StructuredIndex);
1200 
1201  // This is an extension in C. (The builtin _Complex type does not exist
1202  // in the C++ standard.)
1203  if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly)
1204  SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init)
1205  << IList->getSourceRange();
1206 
1207  // Initialize the complex number.
1208  QualType elementType = DeclType->getAs<ComplexType>()->getElementType();
1209  InitializedEntity ElementEntity =
1210  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1211 
1212  for (unsigned i = 0; i < 2; ++i) {
1213  ElementEntity.setElementIndex(Index);
1214  CheckSubElementType(ElementEntity, IList, elementType, Index,
1215  StructuredList, StructuredIndex);
1216  }
1217 }
1218 
1219 
1220 void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
1221  InitListExpr *IList, QualType DeclType,
1222  unsigned &Index,
1223  InitListExpr *StructuredList,
1224  unsigned &StructuredIndex) {
1225  if (Index >= IList->getNumInits()) {
1226  if (!VerifyOnly)
1227  SemaRef.Diag(IList->getLocStart(),
1228  SemaRef.getLangOpts().CPlusPlus11 ?
1229  diag::warn_cxx98_compat_empty_scalar_initializer :
1230  diag::err_empty_scalar_initializer)
1231  << IList->getSourceRange();
1232  hadError = !SemaRef.getLangOpts().CPlusPlus11;
1233  ++Index;
1234  ++StructuredIndex;
1235  return;
1236  }
1237 
1238  Expr *expr = IList->getInit(Index);
1239  if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
1240  // FIXME: This is invalid, and accepting it causes overload resolution
1241  // to pick the wrong overload in some corner cases.
1242  if (!VerifyOnly)
1243  SemaRef.Diag(SubIList->getLocStart(),
1244  diag::ext_many_braces_around_scalar_init)
1245  << SubIList->getSourceRange();
1246 
1247  CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1248  StructuredIndex);
1249  return;
1250  } else if (isa<DesignatedInitExpr>(expr)) {
1251  if (!VerifyOnly)
1252  SemaRef.Diag(expr->getLocStart(),
1253  diag::err_designator_for_scalar_init)
1254  << DeclType << expr->getSourceRange();
1255  hadError = true;
1256  ++Index;
1257  ++StructuredIndex;
1258  return;
1259  }
1260 
1261  if (VerifyOnly) {
1262  if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1263  hadError = true;
1264  ++Index;
1265  return;
1266  }
1267 
1268  ExprResult Result =
1269  SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1270  /*TopLevelOfInitList=*/true);
1271 
1272  Expr *ResultExpr = nullptr;
1273 
1274  if (Result.isInvalid())
1275  hadError = true; // types weren't compatible.
1276  else {
1277  ResultExpr = Result.getAs<Expr>();
1278 
1279  if (ResultExpr != expr) {
1280  // The type was promoted, update initializer list.
1281  IList->setInit(Index, ResultExpr);
1282  }
1283  }
1284  if (hadError)
1285  ++StructuredIndex;
1286  else
1287  UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1288  ++Index;
1289 }
1290 
1291 void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
1292  InitListExpr *IList, QualType DeclType,
1293  unsigned &Index,
1294  InitListExpr *StructuredList,
1295  unsigned &StructuredIndex) {
1296  if (Index >= IList->getNumInits()) {
1297  // FIXME: It would be wonderful if we could point at the actual member. In
1298  // general, it would be useful to pass location information down the stack,
1299  // so that we know the location (or decl) of the "current object" being
1300  // initialized.
1301  if (!VerifyOnly)
1302  SemaRef.Diag(IList->getLocStart(),
1303  diag::err_init_reference_member_uninitialized)
1304  << DeclType
1305  << IList->getSourceRange();
1306  hadError = true;
1307  ++Index;
1308  ++StructuredIndex;
1309  return;
1310  }
1311 
1312  Expr *expr = IList->getInit(Index);
1313  if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) {
1314  if (!VerifyOnly)
1315  SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
1316  << DeclType << IList->getSourceRange();
1317  hadError = true;
1318  ++Index;
1319  ++StructuredIndex;
1320  return;
1321  }
1322 
1323  if (VerifyOnly) {
1324  if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1325  hadError = true;
1326  ++Index;
1327  return;
1328  }
1329 
1330  ExprResult Result =
1331  SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1332  /*TopLevelOfInitList=*/true);
1333 
1334  if (Result.isInvalid())
1335  hadError = true;
1336 
1337  expr = Result.getAs<Expr>();
1338  IList->setInit(Index, expr);
1339 
1340  if (hadError)
1341  ++StructuredIndex;
1342  else
1343  UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1344  ++Index;
1345 }
1346 
1347 void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
1348  InitListExpr *IList, QualType DeclType,
1349  unsigned &Index,
1350  InitListExpr *StructuredList,
1351  unsigned &StructuredIndex) {
1352  const VectorType *VT = DeclType->getAs<VectorType>();
1353  unsigned maxElements = VT->getNumElements();
1354  unsigned numEltsInit = 0;
1355  QualType elementType = VT->getElementType();
1356 
1357  if (Index >= IList->getNumInits()) {
1358  // Make sure the element type can be value-initialized.
1359  if (VerifyOnly)
1360  CheckEmptyInitializable(
1361  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity),
1362  IList->getLocEnd());
1363  return;
1364  }
1365 
1366  if (!SemaRef.getLangOpts().OpenCL) {
1367  // If the initializing element is a vector, try to copy-initialize
1368  // instead of breaking it apart (which is doomed to failure anyway).
1369  Expr *Init = IList->getInit(Index);
1370  if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
1371  if (VerifyOnly) {
1372  if (!SemaRef.CanPerformCopyInitialization(Entity, Init))
1373  hadError = true;
1374  ++Index;
1375  return;
1376  }
1377 
1378  ExprResult Result =
1379  SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(), Init,
1380  /*TopLevelOfInitList=*/true);
1381 
1382  Expr *ResultExpr = nullptr;
1383  if (Result.isInvalid())
1384  hadError = true; // types weren't compatible.
1385  else {
1386  ResultExpr = Result.getAs<Expr>();
1387 
1388  if (ResultExpr != Init) {
1389  // The type was promoted, update initializer list.
1390  IList->setInit(Index, ResultExpr);
1391  }
1392  }
1393  if (hadError)
1394  ++StructuredIndex;
1395  else
1396  UpdateStructuredListElement(StructuredList, StructuredIndex,
1397  ResultExpr);
1398  ++Index;
1399  return;
1400  }
1401 
1402  InitializedEntity ElementEntity =
1403  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1404 
1405  for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1406  // Don't attempt to go past the end of the init list
1407  if (Index >= IList->getNumInits()) {
1408  if (VerifyOnly)
1409  CheckEmptyInitializable(ElementEntity, IList->getLocEnd());
1410  break;
1411  }
1412 
1413  ElementEntity.setElementIndex(Index);
1414  CheckSubElementType(ElementEntity, IList, elementType, Index,
1415  StructuredList, StructuredIndex);
1416  }
1417 
1418  if (VerifyOnly)
1419  return;
1420 
1421  bool isBigEndian = SemaRef.Context.getTargetInfo().isBigEndian();
1422  const VectorType *T = Entity.getType()->getAs<VectorType>();
1423  if (isBigEndian && (T->getVectorKind() == VectorType::NeonVector ||
1424  T->getVectorKind() == VectorType::NeonPolyVector)) {
1425  // The ability to use vector initializer lists is a GNU vector extension
1426  // and is unrelated to the NEON intrinsics in arm_neon.h. On little
1427  // endian machines it works fine, however on big endian machines it
1428  // exhibits surprising behaviour:
1429  //
1430  // uint32x2_t x = {42, 64};
1431  // return vget_lane_u32(x, 0); // Will return 64.
1432  //
1433  // Because of this, explicitly call out that it is non-portable.
1434  //
1435  SemaRef.Diag(IList->getLocStart(),
1436  diag::warn_neon_vector_initializer_non_portable);
1437 
1438  const char *typeCode;
1439  unsigned typeSize = SemaRef.Context.getTypeSize(elementType);
1440 
1441  if (elementType->isFloatingType())
1442  typeCode = "f";
1443  else if (elementType->isSignedIntegerType())
1444  typeCode = "s";
1445  else if (elementType->isUnsignedIntegerType())
1446  typeCode = "u";
1447  else
1448  llvm_unreachable("Invalid element type!");
1449 
1450  SemaRef.Diag(IList->getLocStart(),
1451  SemaRef.Context.getTypeSize(VT) > 64 ?
1452  diag::note_neon_vector_initializer_non_portable_q :
1453  diag::note_neon_vector_initializer_non_portable)
1454  << typeCode << typeSize;
1455  }
1456 
1457  return;
1458  }
1459 
1460  InitializedEntity ElementEntity =
1461  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1462 
1463  // OpenCL initializers allows vectors to be constructed from vectors.
1464  for (unsigned i = 0; i < maxElements; ++i) {
1465  // Don't attempt to go past the end of the init list
1466  if (Index >= IList->getNumInits())
1467  break;
1468 
1469  ElementEntity.setElementIndex(Index);
1470 
1471  QualType IType = IList->getInit(Index)->getType();
1472  if (!IType->isVectorType()) {
1473  CheckSubElementType(ElementEntity, IList, elementType, Index,
1474  StructuredList, StructuredIndex);
1475  ++numEltsInit;
1476  } else {
1477  QualType VecType;
1478  const VectorType *IVT = IType->getAs<VectorType>();
1479  unsigned numIElts = IVT->getNumElements();
1480 
1481  if (IType->isExtVectorType())
1482  VecType = SemaRef.Context.getExtVectorType(elementType, numIElts);
1483  else
1484  VecType = SemaRef.Context.getVectorType(elementType, numIElts,
1485  IVT->getVectorKind());
1486  CheckSubElementType(ElementEntity, IList, VecType, Index,
1487  StructuredList, StructuredIndex);
1488  numEltsInit += numIElts;
1489  }
1490  }
1491 
1492  // OpenCL requires all elements to be initialized.
1493  if (numEltsInit != maxElements) {
1494  if (!VerifyOnly)
1495  SemaRef.Diag(IList->getLocStart(),
1496  diag::err_vector_incorrect_num_initializers)
1497  << (numEltsInit < maxElements) << maxElements << numEltsInit;
1498  hadError = true;
1499  }
1500 }
1501 
1502 void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
1503  InitListExpr *IList, QualType &DeclType,
1504  llvm::APSInt elementIndex,
1505  bool SubobjectIsDesignatorContext,
1506  unsigned &Index,
1507  InitListExpr *StructuredList,
1508  unsigned &StructuredIndex) {
1509  const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType);
1510 
1511  // Check for the special-case of initializing an array with a string.
1512  if (Index < IList->getNumInits()) {
1513  if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) ==
1514  SIF_None) {
1515  // We place the string literal directly into the resulting
1516  // initializer list. This is the only place where the structure
1517  // of the structured initializer list doesn't match exactly,
1518  // because doing so would involve allocating one character
1519  // constant for each string.
1520  if (!VerifyOnly) {
1521  CheckStringInit(IList->getInit(Index), DeclType, arrayType, SemaRef);
1522  UpdateStructuredListElement(StructuredList, StructuredIndex,
1523  IList->getInit(Index));
1524  StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
1525  }
1526  ++Index;
1527  return;
1528  }
1529  }
1530  if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
1531  // Check for VLAs; in standard C it would be possible to check this
1532  // earlier, but I don't know where clang accepts VLAs (gcc accepts
1533  // them in all sorts of strange places).
1534  if (!VerifyOnly)
1535  SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
1536  diag::err_variable_object_no_init)
1537  << VAT->getSizeExpr()->getSourceRange();
1538  hadError = true;
1539  ++Index;
1540  ++StructuredIndex;
1541  return;
1542  }
1543 
1544  // We might know the maximum number of elements in advance.
1545  llvm::APSInt maxElements(elementIndex.getBitWidth(),
1546  elementIndex.isUnsigned());
1547  bool maxElementsKnown = false;
1548  if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) {
1549  maxElements = CAT->getSize();
1550  elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
1551  elementIndex.setIsUnsigned(maxElements.isUnsigned());
1552  maxElementsKnown = true;
1553  }
1554 
1555  QualType elementType = arrayType->getElementType();
1556  while (Index < IList->getNumInits()) {
1557  Expr *Init = IList->getInit(Index);
1558  if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1559  // If we're not the subobject that matches up with the '{' for
1560  // the designator, we shouldn't be handling the
1561  // designator. Return immediately.
1562  if (!SubobjectIsDesignatorContext)
1563  return;
1564 
1565  // Handle this designated initializer. elementIndex will be
1566  // updated to be the next array element we'll initialize.
1567  if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1568  DeclType, nullptr, &elementIndex, Index,
1569  StructuredList, StructuredIndex, true,
1570  false)) {
1571  hadError = true;
1572  continue;
1573  }
1574 
1575  if (elementIndex.getBitWidth() > maxElements.getBitWidth())
1576  maxElements = maxElements.extend(elementIndex.getBitWidth());
1577  else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
1578  elementIndex = elementIndex.extend(maxElements.getBitWidth());
1579  elementIndex.setIsUnsigned(maxElements.isUnsigned());
1580 
1581  // If the array is of incomplete type, keep track of the number of
1582  // elements in the initializer.
1583  if (!maxElementsKnown && elementIndex > maxElements)
1584  maxElements = elementIndex;
1585 
1586  continue;
1587  }
1588 
1589  // If we know the maximum number of elements, and we've already
1590  // hit it, stop consuming elements in the initializer list.
1591  if (maxElementsKnown && elementIndex == maxElements)
1592  break;
1593 
1594  InitializedEntity ElementEntity =
1595  InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
1596  Entity);
1597  // Check this element.
1598  CheckSubElementType(ElementEntity, IList, elementType, Index,
1599  StructuredList, StructuredIndex);
1600  ++elementIndex;
1601 
1602  // If the array is of incomplete type, keep track of the number of
1603  // elements in the initializer.
1604  if (!maxElementsKnown && elementIndex > maxElements)
1605  maxElements = elementIndex;
1606  }
1607  if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) {
1608  // If this is an incomplete array type, the actual type needs to
1609  // be calculated here.
1610  llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
1611  if (maxElements == Zero) {
1612  // Sizing an array implicitly to zero is not allowed by ISO C,
1613  // but is supported by GNU.
1614  SemaRef.Diag(IList->getLocStart(),
1615  diag::ext_typecheck_zero_array_size);
1616  }
1617 
1618  DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
1619  ArrayType::Normal, 0);
1620  }
1621  if (!hadError && VerifyOnly) {
1622  // Check if there are any members of the array that get value-initialized.
1623  // If so, check if doing that is possible.
1624  // FIXME: This needs to detect holes left by designated initializers too.
1625  if (maxElementsKnown && elementIndex < maxElements)
1626  CheckEmptyInitializable(InitializedEntity::InitializeElement(
1627  SemaRef.Context, 0, Entity),
1628  IList->getLocEnd());
1629  }
1630 }
1631 
1632 bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity,
1633  Expr *InitExpr,
1634  FieldDecl *Field,
1635  bool TopLevelObject) {
1636  // Handle GNU flexible array initializers.
1637  unsigned FlexArrayDiag;
1638  if (isa<InitListExpr>(InitExpr) &&
1639  cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
1640  // Empty flexible array init always allowed as an extension
1641  FlexArrayDiag = diag::ext_flexible_array_init;
1642  } else if (SemaRef.getLangOpts().CPlusPlus) {
1643  // Disallow flexible array init in C++; it is not required for gcc
1644  // compatibility, and it needs work to IRGen correctly in general.
1645  FlexArrayDiag = diag::err_flexible_array_init;
1646  } else if (!TopLevelObject) {
1647  // Disallow flexible array init on non-top-level object
1648  FlexArrayDiag = diag::err_flexible_array_init;
1649  } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
1650  // Disallow flexible array init on anything which is not a variable.
1651  FlexArrayDiag = diag::err_flexible_array_init;
1652  } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) {
1653  // Disallow flexible array init on local variables.
1654  FlexArrayDiag = diag::err_flexible_array_init;
1655  } else {
1656  // Allow other cases.
1657  FlexArrayDiag = diag::ext_flexible_array_init;
1658  }
1659 
1660  if (!VerifyOnly) {
1661  SemaRef.Diag(InitExpr->getLocStart(),
1662  FlexArrayDiag)
1663  << InitExpr->getLocStart();
1664  SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1665  << Field;
1666  }
1667 
1668  return FlexArrayDiag != diag::ext_flexible_array_init;
1669 }
1670 
1671 void InitListChecker::CheckStructUnionTypes(const InitializedEntity &Entity,
1672  InitListExpr *IList,
1673  QualType DeclType,
1675  bool SubobjectIsDesignatorContext,
1676  unsigned &Index,
1677  InitListExpr *StructuredList,
1678  unsigned &StructuredIndex,
1679  bool TopLevelObject) {
1680  RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl();
1681 
1682  // If the record is invalid, some of it's members are invalid. To avoid
1683  // confusion, we forgo checking the intializer for the entire record.
1684  if (structDecl->isInvalidDecl()) {
1685  // Assume it was supposed to consume a single initializer.
1686  ++Index;
1687  hadError = true;
1688  return;
1689  }
1690 
1691  if (DeclType->isUnionType() && IList->getNumInits() == 0) {
1692  RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1693 
1694  // If there's a default initializer, use it.
1695  if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
1696  if (VerifyOnly)
1697  return;
1698  for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1699  Field != FieldEnd; ++Field) {
1700  if (Field->hasInClassInitializer()) {
1701  StructuredList->setInitializedFieldInUnion(*Field);
1702  // FIXME: Actually build a CXXDefaultInitExpr?
1703  return;
1704  }
1705  }
1706  }
1707 
1708  // Value-initialize the first member of the union that isn't an unnamed
1709  // bitfield.
1710  for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1711  Field != FieldEnd; ++Field) {
1712  if (!Field->isUnnamedBitfield()) {
1713  if (VerifyOnly)
1714  CheckEmptyInitializable(
1715  InitializedEntity::InitializeMember(*Field, &Entity),
1716  IList->getLocEnd());
1717  else
1718  StructuredList->setInitializedFieldInUnion(*Field);
1719  break;
1720  }
1721  }
1722  return;
1723  }
1724 
1725  // If structDecl is a forward declaration, this loop won't do
1726  // anything except look at designated initializers; That's okay,
1727  // because an error should get printed out elsewhere. It might be
1728  // worthwhile to skip over the rest of the initializer, though.
1729  RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1730  RecordDecl::field_iterator FieldEnd = RD->field_end();
1731  bool InitializedSomething = false;
1732  bool CheckForMissingFields = true;
1733  while (Index < IList->getNumInits()) {
1734  Expr *Init = IList->getInit(Index);
1735 
1736  if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1737  // If we're not the subobject that matches up with the '{' for
1738  // the designator, we shouldn't be handling the
1739  // designator. Return immediately.
1740  if (!SubobjectIsDesignatorContext)
1741  return;
1742 
1743  // Handle this designated initializer. Field will be updated to
1744  // the next field that we'll be initializing.
1745  if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1746  DeclType, &Field, nullptr, Index,
1747  StructuredList, StructuredIndex,
1748  true, TopLevelObject))
1749  hadError = true;
1750 
1751  InitializedSomething = true;
1752 
1753  // Disable check for missing fields when designators are used.
1754  // This matches gcc behaviour.
1755  CheckForMissingFields = false;
1756  continue;
1757  }
1758 
1759  if (Field == FieldEnd) {
1760  // We've run out of fields. We're done.
1761  break;
1762  }
1763 
1764  // We've already initialized a member of a union. We're done.
1765  if (InitializedSomething && DeclType->isUnionType())
1766  break;
1767 
1768  // If we've hit the flexible array member at the end, we're done.
1769  if (Field->getType()->isIncompleteArrayType())
1770  break;
1771 
1772  if (Field->isUnnamedBitfield()) {
1773  // Don't initialize unnamed bitfields, e.g. "int : 20;"
1774  ++Field;
1775  continue;
1776  }
1777 
1778  // Make sure we can use this declaration.
1779  bool InvalidUse;
1780  if (VerifyOnly)
1781  InvalidUse = !SemaRef.CanUseDecl(*Field);
1782  else
1783  InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field,
1784  IList->getInit(Index)->getLocStart());
1785  if (InvalidUse) {
1786  ++Index;
1787  ++Field;
1788  hadError = true;
1789  continue;
1790  }
1791 
1792  InitializedEntity MemberEntity =
1793  InitializedEntity::InitializeMember(*Field, &Entity);
1794  CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1795  StructuredList, StructuredIndex);
1796  InitializedSomething = true;
1797 
1798  if (DeclType->isUnionType() && !VerifyOnly) {
1799  // Initialize the first field within the union.
1800  StructuredList->setInitializedFieldInUnion(*Field);
1801  }
1802 
1803  ++Field;
1804  }
1805 
1806  // Emit warnings for missing struct field initializers.
1807  if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
1808  Field != FieldEnd && !Field->getType()->isIncompleteArrayType() &&
1809  !DeclType->isUnionType()) {
1810  // It is possible we have one or more unnamed bitfields remaining.
1811  // Find first (if any) named field and emit warning.
1812  for (RecordDecl::field_iterator it = Field, end = RD->field_end();
1813  it != end; ++it) {
1814  if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) {
1815  SemaRef.Diag(IList->getSourceRange().getEnd(),
1816  diag::warn_missing_field_initializers) << *it;
1817  break;
1818  }
1819  }
1820  }
1821 
1822  // Check that any remaining fields can be value-initialized.
1823  if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() &&
1824  !Field->getType()->isIncompleteArrayType()) {
1825  // FIXME: Should check for holes left by designated initializers too.
1826  for (; Field != FieldEnd && !hadError; ++Field) {
1827  if (!Field->isUnnamedBitfield() && !Field->hasInClassInitializer())
1828  CheckEmptyInitializable(
1829  InitializedEntity::InitializeMember(*Field, &Entity),
1830  IList->getLocEnd());
1831  }
1832  }
1833 
1834  if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
1835  Index >= IList->getNumInits())
1836  return;
1837 
1838  if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field,
1839  TopLevelObject)) {
1840  hadError = true;
1841  ++Index;
1842  return;
1843  }
1844 
1845  InitializedEntity MemberEntity =
1846  InitializedEntity::InitializeMember(*Field, &Entity);
1847 
1848  if (isa<InitListExpr>(IList->getInit(Index)))
1849  CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1850  StructuredList, StructuredIndex);
1851  else
1852  CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
1853  StructuredList, StructuredIndex);
1854 }
1855 
1856 /// \brief Expand a field designator that refers to a member of an
1857 /// anonymous struct or union into a series of field designators that
1858 /// refers to the field within the appropriate subobject.
1859 ///
1861  DesignatedInitExpr *DIE,
1862  unsigned DesigIdx,
1863  IndirectFieldDecl *IndirectField) {
1865 
1866  // Build the replacement designators.
1868  for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
1869  PE = IndirectField->chain_end(); PI != PE; ++PI) {
1870  if (PI + 1 == PE)
1871  Replacements.push_back(Designator((IdentifierInfo *)nullptr,
1872  DIE->getDesignator(DesigIdx)->getDotLoc(),
1873  DIE->getDesignator(DesigIdx)->getFieldLoc()));
1874  else
1875  Replacements.push_back(Designator((IdentifierInfo *)nullptr,
1877  assert(isa<FieldDecl>(*PI));
1878  Replacements.back().setField(cast<FieldDecl>(*PI));
1879  }
1880 
1881  // Expand the current designator into the set of replacement
1882  // designators, so we have a full subobject path down to where the
1883  // member of the anonymous struct/union is actually stored.
1884  DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
1885  &Replacements[0] + Replacements.size());
1886 }
1887 
1889  DesignatedInitExpr *DIE) {
1890  unsigned NumIndexExprs = DIE->getNumSubExprs() - 1;
1891  SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
1892  for (unsigned I = 0; I < NumIndexExprs; ++I)
1893  IndexExprs[I] = DIE->getSubExpr(I + 1);
1894  return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators_begin(),
1895  DIE->size(), IndexExprs,
1896  DIE->getEqualOrColonLoc(),
1897  DIE->usesGNUSyntax(), DIE->getInit());
1898 }
1899 
1900 namespace {
1901 
1902 // Callback to only accept typo corrections that are for field members of
1903 // the given struct or union.
1904 class FieldInitializerValidatorCCC : public CorrectionCandidateCallback {
1905  public:
1906  explicit FieldInitializerValidatorCCC(RecordDecl *RD)
1907  : Record(RD) {}
1908 
1909  bool ValidateCandidate(const TypoCorrection &candidate) override {
1910  FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>();
1911  return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record);
1912  }
1913 
1914  private:
1915  RecordDecl *Record;
1916 };
1917 
1918 }
1919 
1920 /// @brief Check the well-formedness of a C99 designated initializer.
1921 ///
1922 /// Determines whether the designated initializer @p DIE, which
1923 /// resides at the given @p Index within the initializer list @p
1924 /// IList, is well-formed for a current object of type @p DeclType
1925 /// (C99 6.7.8). The actual subobject that this designator refers to
1926 /// within the current subobject is returned in either
1927 /// @p NextField or @p NextElementIndex (whichever is appropriate).
1928 ///
1929 /// @param IList The initializer list in which this designated
1930 /// initializer occurs.
1931 ///
1932 /// @param DIE The designated initializer expression.
1933 ///
1934 /// @param DesigIdx The index of the current designator.
1935 ///
1936 /// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
1937 /// into which the designation in @p DIE should refer.
1938 ///
1939 /// @param NextField If non-NULL and the first designator in @p DIE is
1940 /// a field, this will be set to the field declaration corresponding
1941 /// to the field named by the designator.
1942 ///
1943 /// @param NextElementIndex If non-NULL and the first designator in @p
1944 /// DIE is an array designator or GNU array-range designator, this
1945 /// will be set to the last index initialized by this designator.
1946 ///
1947 /// @param Index Index into @p IList where the designated initializer
1948 /// @p DIE occurs.
1949 ///
1950 /// @param StructuredList The initializer list expression that
1951 /// describes all of the subobject initializers in the order they'll
1952 /// actually be initialized.
1953 ///
1954 /// @returns true if there was an error, false otherwise.
1955 bool
1956 InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
1957  InitListExpr *IList,
1958  DesignatedInitExpr *DIE,
1959  unsigned DesigIdx,
1960  QualType &CurrentObjectType,
1961  RecordDecl::field_iterator *NextField,
1962  llvm::APSInt *NextElementIndex,
1963  unsigned &Index,
1964  InitListExpr *StructuredList,
1965  unsigned &StructuredIndex,
1966  bool FinishSubobjectInit,
1967  bool TopLevelObject) {
1968  if (DesigIdx == DIE->size()) {
1969  // Check the actual initialization for the designated object type.
1970  bool prevHadError = hadError;
1971 
1972  // Temporarily remove the designator expression from the
1973  // initializer list that the child calls see, so that we don't try
1974  // to re-process the designator.
1975  unsigned OldIndex = Index;
1976  IList->setInit(OldIndex, DIE->getInit());
1977 
1978  CheckSubElementType(Entity, IList, CurrentObjectType, Index,
1979  StructuredList, StructuredIndex);
1980 
1981  // Restore the designated initializer expression in the syntactic
1982  // form of the initializer list.
1983  if (IList->getInit(OldIndex) != DIE->getInit())
1984  DIE->setInit(IList->getInit(OldIndex));
1985  IList->setInit(OldIndex, DIE);
1986 
1987  return hadError && !prevHadError;
1988  }
1989 
1990  DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
1991  bool IsFirstDesignator = (DesigIdx == 0);
1992  if (!VerifyOnly) {
1993  assert((IsFirstDesignator || StructuredList) &&
1994  "Need a non-designated initializer list to start from");
1995 
1996  // Determine the structural initializer list that corresponds to the
1997  // current subobject.
1998  if (IsFirstDesignator)
1999  StructuredList = SyntacticToSemantic.lookup(IList);
2000  else {
2001  Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2002  StructuredList->getInit(StructuredIndex) : nullptr;
2003  if (!ExistingInit && StructuredList->hasArrayFiller())
2004  ExistingInit = StructuredList->getArrayFiller();
2005 
2006  if (!ExistingInit)
2007  StructuredList =
2008  getStructuredSubobjectInit(IList, Index, CurrentObjectType,
2009  StructuredList, StructuredIndex,
2010  SourceRange(D->getLocStart(),
2011  DIE->getLocEnd()));
2012  else if (InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2013  StructuredList = Result;
2014  else {
2015  if (DesignatedInitUpdateExpr *E =
2016  dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2017  StructuredList = E->getUpdater();
2018  else {
2019  DesignatedInitUpdateExpr *DIUE =
2020  new (SemaRef.Context) DesignatedInitUpdateExpr(SemaRef.Context,
2021  D->getLocStart(), ExistingInit,
2022  DIE->getLocEnd());
2023  StructuredList->updateInit(SemaRef.Context, StructuredIndex, DIUE);
2024  StructuredList = DIUE->getUpdater();
2025  }
2026 
2027  // We need to check on source range validity because the previous
2028  // initializer does not have to be an explicit initializer. e.g.,
2029  //
2030  // struct P { int a, b; };
2031  // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2032  //
2033  // There is an overwrite taking place because the first braced initializer
2034  // list "{ .a = 2 }" already provides value for .p.b (which is zero).
2035  if (ExistingInit->getSourceRange().isValid()) {
2036  // We are creating an initializer list that initializes the
2037  // subobjects of the current object, but there was already an
2038  // initialization that completely initialized the current
2039  // subobject, e.g., by a compound literal:
2040  //
2041  // struct X { int a, b; };
2042  // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2043  //
2044  // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2045  // designated initializer re-initializes the whole
2046  // subobject [0], overwriting previous initializers.
2047  SemaRef.Diag(D->getLocStart(),
2048  diag::warn_subobject_initializer_overrides)
2049  << SourceRange(D->getLocStart(), DIE->getLocEnd());
2050 
2051  SemaRef.Diag(ExistingInit->getLocStart(),
2052  diag::note_previous_initializer)
2053  << /*FIXME:has side effects=*/0
2054  << ExistingInit->getSourceRange();
2055  }
2056  }
2057  }
2058  assert(StructuredList && "Expected a structured initializer list");
2059  }
2060 
2061  if (D->isFieldDesignator()) {
2062  // C99 6.7.8p7:
2063  //
2064  // If a designator has the form
2065  //
2066  // . identifier
2067  //
2068  // then the current object (defined below) shall have
2069  // structure or union type and the identifier shall be the
2070  // name of a member of that type.
2071  const RecordType *RT = CurrentObjectType->getAs<RecordType>();
2072  if (!RT) {
2073  SourceLocation Loc = D->getDotLoc();
2074  if (Loc.isInvalid())
2075  Loc = D->getFieldLoc();
2076  if (!VerifyOnly)
2077  SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
2078  << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
2079  ++Index;
2080  return true;
2081  }
2082 
2083  FieldDecl *KnownField = D->getField();
2084  if (!KnownField) {
2085  IdentifierInfo *FieldName = D->getFieldName();
2086  DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
2087  for (NamedDecl *ND : Lookup) {
2088  if (auto *FD = dyn_cast<FieldDecl>(ND)) {
2089  KnownField = FD;
2090  break;
2091  }
2092  if (auto *IFD = dyn_cast<IndirectFieldDecl>(ND)) {
2093  // In verify mode, don't modify the original.
2094  if (VerifyOnly)
2095  DIE = CloneDesignatedInitExpr(SemaRef, DIE);
2096  ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IFD);
2097  D = DIE->getDesignator(DesigIdx);
2098  KnownField = cast<FieldDecl>(*IFD->chain_begin());
2099  break;
2100  }
2101  }
2102  if (!KnownField) {
2103  if (VerifyOnly) {
2104  ++Index;
2105  return true; // No typo correction when just trying this out.
2106  }
2107 
2108  // Name lookup found something, but it wasn't a field.
2109  if (!Lookup.empty()) {
2110  SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
2111  << FieldName;
2112  SemaRef.Diag(Lookup.front()->getLocation(),
2113  diag::note_field_designator_found);
2114  ++Index;
2115  return true;
2116  }
2117 
2118  // Name lookup didn't find anything.
2119  // Determine whether this was a typo for another field name.
2120  if (TypoCorrection Corrected = SemaRef.CorrectTypo(
2121  DeclarationNameInfo(FieldName, D->getFieldLoc()),
2122  Sema::LookupMemberName, /*Scope=*/nullptr, /*SS=*/nullptr,
2123  llvm::make_unique<FieldInitializerValidatorCCC>(RT->getDecl()),
2124  Sema::CTK_ErrorRecovery, RT->getDecl())) {
2125  SemaRef.diagnoseTypo(
2126  Corrected,
2127  SemaRef.PDiag(diag::err_field_designator_unknown_suggest)
2128  << FieldName << CurrentObjectType);
2129  KnownField = Corrected.getCorrectionDeclAs<FieldDecl>();
2130  hadError = true;
2131  } else {
2132  // Typo correction didn't find anything.
2133  SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
2134  << FieldName << CurrentObjectType;
2135  ++Index;
2136  return true;
2137  }
2138  }
2139  }
2140 
2141  unsigned FieldIndex = 0;
2142  for (auto *FI : RT->getDecl()->fields()) {
2143  if (FI->isUnnamedBitfield())
2144  continue;
2145  if (KnownField == FI)
2146  break;
2147  ++FieldIndex;
2148  }
2149 
2152 
2153  // All of the fields of a union are located at the same place in
2154  // the initializer list.
2155  if (RT->getDecl()->isUnion()) {
2156  FieldIndex = 0;
2157  if (!VerifyOnly) {
2158  FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2159  if (CurrentField && CurrentField != *Field) {
2160  assert(StructuredList->getNumInits() == 1
2161  && "A union should never have more than one initializer!");
2162 
2163  // we're about to throw away an initializer, emit warning
2164  SemaRef.Diag(D->getFieldLoc(),
2165  diag::warn_initializer_overrides)
2166  << D->getSourceRange();
2167  Expr *ExistingInit = StructuredList->getInit(0);
2168  SemaRef.Diag(ExistingInit->getLocStart(),
2169  diag::note_previous_initializer)
2170  << /*FIXME:has side effects=*/0
2171  << ExistingInit->getSourceRange();
2172 
2173  // remove existing initializer
2174  StructuredList->resizeInits(SemaRef.Context, 0);
2175  StructuredList->setInitializedFieldInUnion(nullptr);
2176  }
2177 
2178  StructuredList->setInitializedFieldInUnion(*Field);
2179  }
2180  }
2181 
2182  // Make sure we can use this declaration.
2183  bool InvalidUse;
2184  if (VerifyOnly)
2185  InvalidUse = !SemaRef.CanUseDecl(*Field);
2186  else
2187  InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
2188  if (InvalidUse) {
2189  ++Index;
2190  return true;
2191  }
2192 
2193  if (!VerifyOnly) {
2194  // Update the designator with the field declaration.
2195  D->setField(*Field);
2196 
2197  // Make sure that our non-designated initializer list has space
2198  // for a subobject corresponding to this field.
2199  if (FieldIndex >= StructuredList->getNumInits())
2200  StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
2201  }
2202 
2203  // This designator names a flexible array member.
2204  if (Field->getType()->isIncompleteArrayType()) {
2205  bool Invalid = false;
2206  if ((DesigIdx + 1) != DIE->size()) {
2207  // We can't designate an object within the flexible array
2208  // member (because GCC doesn't allow it).
2209  if (!VerifyOnly) {
2211  = DIE->getDesignator(DesigIdx + 1);
2212  SemaRef.Diag(NextD->getLocStart(),
2213  diag::err_designator_into_flexible_array_member)
2214  << SourceRange(NextD->getLocStart(),
2215  DIE->getLocEnd());
2216  SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2217  << *Field;
2218  }
2219  Invalid = true;
2220  }
2221 
2222  if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
2223  !isa<StringLiteral>(DIE->getInit())) {
2224  // The initializer is not an initializer list.
2225  if (!VerifyOnly) {
2226  SemaRef.Diag(DIE->getInit()->getLocStart(),
2227  diag::err_flexible_array_init_needs_braces)
2228  << DIE->getInit()->getSourceRange();
2229  SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2230  << *Field;
2231  }
2232  Invalid = true;
2233  }
2234 
2235  // Check GNU flexible array initializer.
2236  if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
2237  TopLevelObject))
2238  Invalid = true;
2239 
2240  if (Invalid) {
2241  ++Index;
2242  return true;
2243  }
2244 
2245  // Initialize the array.
2246  bool prevHadError = hadError;
2247  unsigned newStructuredIndex = FieldIndex;
2248  unsigned OldIndex = Index;
2249  IList->setInit(Index, DIE->getInit());
2250 
2251  InitializedEntity MemberEntity =
2252  InitializedEntity::InitializeMember(*Field, &Entity);
2253  CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
2254  StructuredList, newStructuredIndex);
2255 
2256  IList->setInit(OldIndex, DIE);
2257  if (hadError && !prevHadError) {
2258  ++Field;
2259  ++FieldIndex;
2260  if (NextField)
2261  *NextField = Field;
2262  StructuredIndex = FieldIndex;
2263  return true;
2264  }
2265  } else {
2266  // Recurse to check later designated subobjects.
2267  QualType FieldType = Field->getType();
2268  unsigned newStructuredIndex = FieldIndex;
2269 
2270  InitializedEntity MemberEntity =
2271  InitializedEntity::InitializeMember(*Field, &Entity);
2272  if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2273  FieldType, nullptr, nullptr, Index,
2274  StructuredList, newStructuredIndex,
2275  true, false))
2276  return true;
2277  }
2278 
2279  // Find the position of the next field to be initialized in this
2280  // subobject.
2281  ++Field;
2282  ++FieldIndex;
2283 
2284  // If this the first designator, our caller will continue checking
2285  // the rest of this struct/class/union subobject.
2286  if (IsFirstDesignator) {
2287  if (NextField)
2288  *NextField = Field;
2289  StructuredIndex = FieldIndex;
2290  return false;
2291  }
2292 
2293  if (!FinishSubobjectInit)
2294  return false;
2295 
2296  // We've already initialized something in the union; we're done.
2297  if (RT->getDecl()->isUnion())
2298  return hadError;
2299 
2300  // Check the remaining fields within this class/struct/union subobject.
2301  bool prevHadError = hadError;
2302 
2303  CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index,
2304  StructuredList, FieldIndex);
2305  return hadError && !prevHadError;
2306  }
2307 
2308  // C99 6.7.8p6:
2309  //
2310  // If a designator has the form
2311  //
2312  // [ constant-expression ]
2313  //
2314  // then the current object (defined below) shall have array
2315  // type and the expression shall be an integer constant
2316  // expression. If the array is of unknown size, any
2317  // nonnegative value is valid.
2318  //
2319  // Additionally, cope with the GNU extension that permits
2320  // designators of the form
2321  //
2322  // [ constant-expression ... constant-expression ]
2323  const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
2324  if (!AT) {
2325  if (!VerifyOnly)
2326  SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
2327  << CurrentObjectType;
2328  ++Index;
2329  return true;
2330  }
2331 
2332  Expr *IndexExpr = nullptr;
2333  llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2334  if (D->isArrayDesignator()) {
2335  IndexExpr = DIE->getArrayIndex(*D);
2336  DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
2337  DesignatedEndIndex = DesignatedStartIndex;
2338  } else {
2339  assert(D->isArrayRangeDesignator() && "Need array-range designator");
2340 
2341  DesignatedStartIndex =
2343  DesignatedEndIndex =
2344  DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
2345  IndexExpr = DIE->getArrayRangeEnd(*D);
2346 
2347  // Codegen can't handle evaluating array range designators that have side
2348  // effects, because we replicate the AST value for each initialized element.
2349  // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
2350  // elements with something that has a side effect, so codegen can emit an
2351  // "error unsupported" error instead of miscompiling the app.
2352  if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
2353  DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
2354  FullyStructuredList->sawArrayRangeDesignator();
2355  }
2356 
2357  if (isa<ConstantArrayType>(AT)) {
2358  llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
2359  DesignatedStartIndex
2360  = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
2361  DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
2362  DesignatedEndIndex
2363  = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
2364  DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2365  if (DesignatedEndIndex >= MaxElements) {
2366  if (!VerifyOnly)
2367  SemaRef.Diag(IndexExpr->getLocStart(),
2368  diag::err_array_designator_too_large)
2369  << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
2370  << IndexExpr->getSourceRange();
2371  ++Index;
2372  return true;
2373  }
2374  } else {
2375  unsigned DesignatedIndexBitWidth =
2376  ConstantArrayType::getMaxSizeBits(SemaRef.Context);
2377  DesignatedStartIndex =
2378  DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
2379  DesignatedEndIndex =
2380  DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
2381  DesignatedStartIndex.setIsUnsigned(true);
2382  DesignatedEndIndex.setIsUnsigned(true);
2383  }
2384 
2385  if (!VerifyOnly && StructuredList->isStringLiteralInit()) {
2386  // We're modifying a string literal init; we have to decompose the string
2387  // so we can modify the individual characters.
2388  ASTContext &Context = SemaRef.Context;
2389  Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2390 
2391  // Compute the character type
2392  QualType CharTy = AT->getElementType();
2393 
2394  // Compute the type of the integer literals.
2395  QualType PromotedCharTy = CharTy;
2396  if (CharTy->isPromotableIntegerType())
2397  PromotedCharTy = Context.getPromotedIntegerType(CharTy);
2398  unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
2399 
2400  if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
2401  // Get the length of the string.
2402  uint64_t StrLen = SL->getLength();
2403  if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2404  StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2405  StructuredList->resizeInits(Context, StrLen);
2406 
2407  // Build a literal for each character in the string, and put them into
2408  // the init list.
2409  for (unsigned i = 0, e = StrLen; i != e; ++i) {
2410  llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2411  Expr *Init = new (Context) IntegerLiteral(
2412  Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2413  if (CharTy != PromotedCharTy)
2414  Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2415  Init, nullptr, VK_RValue);
2416  StructuredList->updateInit(Context, i, Init);
2417  }
2418  } else {
2419  ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
2420  std::string Str;
2421  Context.getObjCEncodingForType(E->getEncodedType(), Str);
2422 
2423  // Get the length of the string.
2424  uint64_t StrLen = Str.size();
2425  if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2426  StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2427  StructuredList->resizeInits(Context, StrLen);
2428 
2429  // Build a literal for each character in the string, and put them into
2430  // the init list.
2431  for (unsigned i = 0, e = StrLen; i != e; ++i) {
2432  llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2433  Expr *Init = new (Context) IntegerLiteral(
2434  Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2435  if (CharTy != PromotedCharTy)
2436  Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2437  Init, nullptr, VK_RValue);
2438  StructuredList->updateInit(Context, i, Init);
2439  }
2440  }
2441  }
2442 
2443  // Make sure that our non-designated initializer list has space
2444  // for a subobject corresponding to this array element.
2445  if (!VerifyOnly &&
2446  DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
2447  StructuredList->resizeInits(SemaRef.Context,
2448  DesignatedEndIndex.getZExtValue() + 1);
2449 
2450  // Repeatedly perform subobject initializations in the range
2451  // [DesignatedStartIndex, DesignatedEndIndex].
2452 
2453  // Move to the next designator
2454  unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
2455  unsigned OldIndex = Index;
2456 
2457  InitializedEntity ElementEntity =
2458  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
2459 
2460  while (DesignatedStartIndex <= DesignatedEndIndex) {
2461  // Recurse to check later designated subobjects.
2462  QualType ElementType = AT->getElementType();
2463  Index = OldIndex;
2464 
2465  ElementEntity.setElementIndex(ElementIndex);
2466  if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1,
2467  ElementType, nullptr, nullptr, Index,
2468  StructuredList, ElementIndex,
2469  (DesignatedStartIndex == DesignatedEndIndex),
2470  false))
2471  return true;
2472 
2473  // Move to the next index in the array that we'll be initializing.
2474  ++DesignatedStartIndex;
2475  ElementIndex = DesignatedStartIndex.getZExtValue();
2476  }
2477 
2478  // If this the first designator, our caller will continue checking
2479  // the rest of this array subobject.
2480  if (IsFirstDesignator) {
2481  if (NextElementIndex)
2482  *NextElementIndex = DesignatedStartIndex;
2483  StructuredIndex = ElementIndex;
2484  return false;
2485  }
2486 
2487  if (!FinishSubobjectInit)
2488  return false;
2489 
2490  // Check the remaining elements within this array subobject.
2491  bool prevHadError = hadError;
2492  CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
2493  /*SubobjectIsDesignatorContext=*/false, Index,
2494  StructuredList, ElementIndex);
2495  return hadError && !prevHadError;
2496 }
2497 
2498 // Get the structured initializer list for a subobject of type
2499 // @p CurrentObjectType.
2500 InitListExpr *
2501 InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2502  QualType CurrentObjectType,
2503  InitListExpr *StructuredList,
2504  unsigned StructuredIndex,
2505  SourceRange InitRange,
2506  bool IsFullyOverwritten) {
2507  if (VerifyOnly)
2508  return nullptr; // No structured list in verification-only mode.
2509  Expr *ExistingInit = nullptr;
2510  if (!StructuredList)
2511  ExistingInit = SyntacticToSemantic.lookup(IList);
2512  else if (StructuredIndex < StructuredList->getNumInits())
2513  ExistingInit = StructuredList->getInit(StructuredIndex);
2514 
2515  if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2516  // There might have already been initializers for subobjects of the current
2517  // object, but a subsequent initializer list will overwrite the entirety
2518  // of the current object. (See DR 253 and C99 6.7.8p21). e.g.,
2519  //
2520  // struct P { char x[6]; };
2521  // struct P l = { .x[2] = 'x', .x = { [0] = 'f' } };
2522  //
2523  // The first designated initializer is ignored, and l.x is just "f".
2524  if (!IsFullyOverwritten)
2525  return Result;
2526 
2527  if (ExistingInit) {
2528  // We are creating an initializer list that initializes the
2529  // subobjects of the current object, but there was already an
2530  // initialization that completely initialized the current
2531  // subobject, e.g., by a compound literal:
2532  //
2533  // struct X { int a, b; };
2534  // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2535  //
2536  // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2537  // designated initializer re-initializes the whole
2538  // subobject [0], overwriting previous initializers.
2539  SemaRef.Diag(InitRange.getBegin(),
2540  diag::warn_subobject_initializer_overrides)
2541  << InitRange;
2542  SemaRef.Diag(ExistingInit->getLocStart(),
2543  diag::note_previous_initializer)
2544  << /*FIXME:has side effects=*/0
2545  << ExistingInit->getSourceRange();
2546  }
2547 
2548  InitListExpr *Result
2549  = new (SemaRef.Context) InitListExpr(SemaRef.Context,
2550  InitRange.getBegin(), None,
2551  InitRange.getEnd());
2552 
2553  QualType ResultType = CurrentObjectType;
2554  if (!ResultType->isArrayType())
2555  ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2556  Result->setType(ResultType);
2557 
2558  // Pre-allocate storage for the structured initializer list.
2559  unsigned NumElements = 0;
2560  unsigned NumInits = 0;
2561  bool GotNumInits = false;
2562  if (!StructuredList) {
2563  NumInits = IList->getNumInits();
2564  GotNumInits = true;
2565  } else if (Index < IList->getNumInits()) {
2566  if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
2567  NumInits = SubList->getNumInits();
2568  GotNumInits = true;
2569  }
2570  }
2571 
2572  if (const ArrayType *AType
2573  = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2574  if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2575  NumElements = CAType->getSize().getZExtValue();
2576  // Simple heuristic so that we don't allocate a very large
2577  // initializer with many empty entries at the end.
2578  if (GotNumInits && NumElements > NumInits)
2579  NumElements = 0;
2580  }
2581  } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
2582  NumElements = VType->getNumElements();
2583  else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
2584  RecordDecl *RDecl = RType->getDecl();
2585  if (RDecl->isUnion())
2586  NumElements = 1;
2587  else
2588  NumElements = std::distance(RDecl->field_begin(), RDecl->field_end());
2589  }
2590 
2591  Result->reserveInits(SemaRef.Context, NumElements);
2592 
2593  // Link this new initializer list into the structured initializer
2594  // lists.
2595  if (StructuredList)
2596  StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
2597  else {
2598  Result->setSyntacticForm(IList);
2599  SyntacticToSemantic[IList] = Result;
2600  }
2601 
2602  return Result;
2603 }
2604 
2605 /// Update the initializer at index @p StructuredIndex within the
2606 /// structured initializer list to the value @p expr.
2607 void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2608  unsigned &StructuredIndex,
2609  Expr *expr) {
2610  // No structured initializer list to update
2611  if (!StructuredList)
2612  return;
2613 
2614  if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2615  StructuredIndex, expr)) {
2616  // This initializer overwrites a previous initializer. Warn.
2617  // We need to check on source range validity because the previous
2618  // initializer does not have to be an explicit initializer.
2619  // struct P { int a, b; };
2620  // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2621  // There is an overwrite taking place because the first braced initializer
2622  // list "{ .a = 2 }' already provides value for .p.b (which is zero).
2623  if (PrevInit->getSourceRange().isValid()) {
2624  SemaRef.Diag(expr->getLocStart(),
2625  diag::warn_initializer_overrides)
2626  << expr->getSourceRange();
2627 
2628  SemaRef.Diag(PrevInit->getLocStart(),
2629  diag::note_previous_initializer)
2630  << /*FIXME:has side effects=*/0
2631  << PrevInit->getSourceRange();
2632  }
2633  }
2634 
2635  ++StructuredIndex;
2636 }
2637 
2638 /// Check that the given Index expression is a valid array designator
2639 /// value. This is essentially just a wrapper around
2640 /// VerifyIntegerConstantExpression that also checks for negative values
2641 /// and produces a reasonable diagnostic if there is a
2642 /// failure. Returns the index expression, possibly with an implicit cast
2643 /// added, on success. If everything went okay, Value will receive the
2644 /// value of the constant expression.
2645 static ExprResult
2646 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
2647  SourceLocation Loc = Index->getLocStart();
2648 
2649  // Make sure this is an integer constant expression.
2650  ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value);
2651  if (Result.isInvalid())
2652  return Result;
2653 
2654  if (Value.isSigned() && Value.isNegative())
2655  return S.Diag(Loc, diag::err_array_designator_negative)
2656  << Value.toString(10) << Index->getSourceRange();
2657 
2658  Value.setIsUnsigned(true);
2659  return Result;
2660 }
2661 
2662 ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
2663  SourceLocation Loc,
2664  bool GNUSyntax,
2665  ExprResult Init) {
2666  typedef DesignatedInitExpr::Designator ASTDesignator;
2667 
2668  bool Invalid = false;
2669  SmallVector<ASTDesignator, 32> Designators;
2670  SmallVector<Expr *, 32> InitExpressions;
2671 
2672  // Build designators and check array designator expressions.
2673  for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2674  const Designator &D = Desig.getDesignator(Idx);
2675  switch (D.getKind()) {
2677  Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
2678  D.getFieldLoc()));
2679  break;
2680 
2682  Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2683  llvm::APSInt IndexValue;
2684  if (!Index->isTypeDependent() && !Index->isValueDependent())
2685  Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get();
2686  if (!Index)
2687  Invalid = true;
2688  else {
2689  Designators.push_back(ASTDesignator(InitExpressions.size(),
2690  D.getLBracketLoc(),
2691  D.getRBracketLoc()));
2692  InitExpressions.push_back(Index);
2693  }
2694  break;
2695  }
2696 
2698  Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
2699  Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
2700  llvm::APSInt StartValue;
2701  llvm::APSInt EndValue;
2702  bool StartDependent = StartIndex->isTypeDependent() ||
2703  StartIndex->isValueDependent();
2704  bool EndDependent = EndIndex->isTypeDependent() ||
2705  EndIndex->isValueDependent();
2706  if (!StartDependent)
2707  StartIndex =
2708  CheckArrayDesignatorExpr(*this, StartIndex, StartValue).get();
2709  if (!EndDependent)
2710  EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).get();
2711 
2712  if (!StartIndex || !EndIndex)
2713  Invalid = true;
2714  else {
2715  // Make sure we're comparing values with the same bit width.
2716  if (StartDependent || EndDependent) {
2717  // Nothing to compute.
2718  } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
2719  EndValue = EndValue.extend(StartValue.getBitWidth());
2720  else if (StartValue.getBitWidth() < EndValue.getBitWidth())
2721  StartValue = StartValue.extend(EndValue.getBitWidth());
2722 
2723  if (!StartDependent && !EndDependent && EndValue < StartValue) {
2724  Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
2725  << StartValue.toString(10) << EndValue.toString(10)
2726  << StartIndex->getSourceRange() << EndIndex->getSourceRange();
2727  Invalid = true;
2728  } else {
2729  Designators.push_back(ASTDesignator(InitExpressions.size(),
2730  D.getLBracketLoc(),
2731  D.getEllipsisLoc(),
2732  D.getRBracketLoc()));
2733  InitExpressions.push_back(StartIndex);
2734  InitExpressions.push_back(EndIndex);
2735  }
2736  }
2737  break;
2738  }
2739  }
2740  }
2741 
2742  if (Invalid || Init.isInvalid())
2743  return ExprError();
2744 
2745  // Clear out the expressions within the designation.
2746  Desig.ClearExprs(*this);
2747 
2748  DesignatedInitExpr *DIE
2749  = DesignatedInitExpr::Create(Context,
2750  Designators.data(), Designators.size(),
2751  InitExpressions, Loc, GNUSyntax,
2752  Init.getAs<Expr>());
2753 
2754  if (!getLangOpts().C99)
2755  Diag(DIE->getLocStart(), diag::ext_designated_init)
2756  << DIE->getSourceRange();
2757 
2758  return DIE;
2759 }
2760 
2761 //===----------------------------------------------------------------------===//
2762 // Initialization entity
2763 //===----------------------------------------------------------------------===//
2764 
2765 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
2766  const InitializedEntity &Parent)
2767  : Parent(&Parent), Index(Index)
2768 {
2769  if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
2770  Kind = EK_ArrayElement;
2771  Type = AT->getElementType();
2772  } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
2773  Kind = EK_VectorElement;
2774  Type = VT->getElementType();
2775  } else {
2776  const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
2777  assert(CT && "Unexpected type");
2778  Kind = EK_ComplexElement;
2779  Type = CT->getElementType();
2780  }
2781 }
2782 
2785  const CXXBaseSpecifier *Base,
2786  bool IsInheritedVirtualBase) {
2788  Result.Kind = EK_Base;
2789  Result.Parent = nullptr;
2790  Result.Base = reinterpret_cast<uintptr_t>(Base);
2791  if (IsInheritedVirtualBase)
2792  Result.Base |= 0x01;
2793 
2794  Result.Type = Base->getType();
2795  return Result;
2796 }
2797 
2799  switch (getKind()) {
2800  case EK_Parameter:
2801  case EK_Parameter_CF_Audited: {
2802  ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2803  return (D ? D->getDeclName() : DeclarationName());
2804  }
2805 
2806  case EK_Variable:
2807  case EK_Member:
2808  return VariableOrMember->getDeclName();
2809 
2810  case EK_LambdaCapture:
2811  return DeclarationName(Capture.VarID);
2812 
2813  case EK_Result:
2814  case EK_Exception:
2815  case EK_New:
2816  case EK_Temporary:
2817  case EK_Base:
2818  case EK_Delegating:
2819  case EK_ArrayElement:
2820  case EK_VectorElement:
2821  case EK_ComplexElement:
2822  case EK_BlockElement:
2824  case EK_RelatedResult:
2825  return DeclarationName();
2826  }
2827 
2828  llvm_unreachable("Invalid EntityKind!");
2829 }
2830 
2832  switch (getKind()) {
2833  case EK_Variable:
2834  case EK_Member:
2835  return VariableOrMember;
2836 
2837  case EK_Parameter:
2839  return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2840 
2841  case EK_Result:
2842  case EK_Exception:
2843  case EK_New:
2844  case EK_Temporary:
2845  case EK_Base:
2846  case EK_Delegating:
2847  case EK_ArrayElement:
2848  case EK_VectorElement:
2849  case EK_ComplexElement:
2850  case EK_BlockElement:
2851  case EK_LambdaCapture:
2853  case EK_RelatedResult:
2854  return nullptr;
2855  }
2856 
2857  llvm_unreachable("Invalid EntityKind!");
2858 }
2859 
2861  switch (getKind()) {
2862  case EK_Result:
2863  case EK_Exception:
2864  return LocAndNRVO.NRVO;
2865 
2866  case EK_Variable:
2867  case EK_Parameter:
2869  case EK_Member:
2870  case EK_New:
2871  case EK_Temporary:
2873  case EK_Base:
2874  case EK_Delegating:
2875  case EK_ArrayElement:
2876  case EK_VectorElement:
2877  case EK_ComplexElement:
2878  case EK_BlockElement:
2879  case EK_LambdaCapture:
2880  case EK_RelatedResult:
2881  break;
2882  }
2883 
2884  return false;
2885 }
2886 
2887 unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
2888  assert(getParent() != this);
2889  unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
2890  for (unsigned I = 0; I != Depth; ++I)
2891  OS << "`-";
2892 
2893  switch (getKind()) {
2894  case EK_Variable: OS << "Variable"; break;
2895  case EK_Parameter: OS << "Parameter"; break;
2896  case EK_Parameter_CF_Audited: OS << "CF audited function Parameter";
2897  break;
2898  case EK_Result: OS << "Result"; break;
2899  case EK_Exception: OS << "Exception"; break;
2900  case EK_Member: OS << "Member"; break;
2901  case EK_New: OS << "New"; break;
2902  case EK_Temporary: OS << "Temporary"; break;
2903  case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
2904  case EK_RelatedResult: OS << "RelatedResult"; break;
2905  case EK_Base: OS << "Base"; break;
2906  case EK_Delegating: OS << "Delegating"; break;
2907  case EK_ArrayElement: OS << "ArrayElement " << Index; break;
2908  case EK_VectorElement: OS << "VectorElement " << Index; break;
2909  case EK_ComplexElement: OS << "ComplexElement " << Index; break;
2910  case EK_BlockElement: OS << "Block"; break;
2911  case EK_LambdaCapture:
2912  OS << "LambdaCapture ";
2913  OS << DeclarationName(Capture.VarID);
2914  break;
2915  }
2916 
2917  if (Decl *D = getDecl()) {
2918  OS << " ";
2919  cast<NamedDecl>(D)->printQualifiedName(OS);
2920  }
2921 
2922  OS << " '" << getType().getAsString() << "'\n";
2923 
2924  return Depth + 1;
2925 }
2926 
2928  dumpImpl(llvm::errs());
2929 }
2930 
2931 //===----------------------------------------------------------------------===//
2932 // Initialization sequence
2933 //===----------------------------------------------------------------------===//
2934 
2936  switch (Kind) {
2941  case SK_BindReference:
2944  case SK_UserConversion:
2948  case SK_AtomicConversion:
2949  case SK_LValueToRValue:
2950  case SK_ListInitialization:
2951  case SK_UnwrapInitList:
2952  case SK_RewrapInitList:
2955  case SK_ZeroInitialization:
2956  case SK_CAssignment:
2957  case SK_StringInit:
2959  case SK_ArrayInit:
2963  case SK_ProduceObjCObject:
2964  case SK_StdInitializerList:
2966  case SK_OCLSamplerInit:
2967  case SK_OCLZeroEvent:
2968  break;
2969 
2970  case SK_ConversionSequence:
2972  delete ICS;
2973  }
2974 }
2975 
2977  return !Steps.empty() && Steps.back().Kind == SK_BindReference;
2978 }
2979 
2981  if (!Failed())
2982  return false;
2983 
2984  switch (getFailureKind()) {
2986  case FK_ArrayNeedsInitList:
2992  case FK_AddressOfOverloadFailed: // FIXME: Could do better
2998  case FK_ConversionFailed:
3003  case FK_DefaultInitOfConst:
3004  case FK_Incomplete:
3005  case FK_ArrayTypeMismatch:
3009  case FK_PlaceholderType:
3011  return false;
3012 
3017  return FailedOverloadResult == OR_Ambiguous;
3018  }
3019 
3020  llvm_unreachable("Invalid EntityKind!");
3021 }
3022 
3024  return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
3025 }
3026 
3027 void
3030  DeclAccessPair Found,
3031  bool HadMultipleCandidates) {
3032  Step S;
3034  S.Type = Function->getType();
3035  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3036  S.Function.Function = Function;
3037  S.Function.FoundDecl = Found;
3038  Steps.push_back(S);
3039 }
3040 
3042  ExprValueKind VK) {
3043  Step S;
3044  switch (VK) {
3045  case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
3046  case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
3047  case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
3048  }
3049  S.Type = BaseType;
3050  Steps.push_back(S);
3051 }
3052 
3054  bool BindingTemporary) {
3055  Step S;
3056  S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
3057  S.Type = T;
3058  Steps.push_back(S);
3059 }
3060 
3062  Step S;
3064  S.Type = T;
3065  Steps.push_back(S);
3066 }
3067 
3068 void
3070  DeclAccessPair FoundDecl,
3071  QualType T,
3072  bool HadMultipleCandidates) {
3073  Step S;
3074  S.Kind = SK_UserConversion;
3075  S.Type = T;
3076  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3077  S.Function.Function = Function;
3078  S.Function.FoundDecl = FoundDecl;
3079  Steps.push_back(S);
3080 }
3081 
3083  ExprValueKind VK) {
3084  Step S;
3085  S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
3086  switch (VK) {
3087  case VK_RValue:
3089  break;
3090  case VK_XValue:
3092  break;
3093  case VK_LValue:
3095  break;
3096  }
3097  S.Type = Ty;
3098  Steps.push_back(S);
3099 }
3100 
3102  Step S;
3104  S.Type = Ty;
3105  Steps.push_back(S);
3106 }
3107 
3109  assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
3110 
3111  Step S;
3112  S.Kind = SK_LValueToRValue;
3113  S.Type = Ty;
3114  Steps.push_back(S);
3115 }
3116 
3118  const ImplicitConversionSequence &ICS, QualType T,
3119  bool TopLevelOfInitList) {
3120  Step S;
3121  S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing
3123  S.Type = T;
3124  S.ICS = new ImplicitConversionSequence(ICS);
3125  Steps.push_back(S);
3126 }
3127 
3129  Step S;
3131  S.Type = T;
3132  Steps.push_back(S);
3133 }
3134 
3135 void
3138  AccessSpecifier Access,
3139  QualType T,
3140  bool HadMultipleCandidates,
3141  bool FromInitList, bool AsInitList) {
3142  Step S;
3143  S.Kind = FromInitList ? AsInitList ? SK_StdInitializerListConstructorCall
3146  S.Type = T;
3147  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3148  S.Function.Function = Constructor;
3149  S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access);
3150  Steps.push_back(S);
3151 }
3152 
3154  Step S;
3156  S.Type = T;
3157  Steps.push_back(S);
3158 }
3159 
3161  Step S;
3162  S.Kind = SK_CAssignment;
3163  S.Type = T;
3164  Steps.push_back(S);
3165 }
3166 
3168  Step S;
3169  S.Kind = SK_StringInit;
3170  S.Type = T;
3171  Steps.push_back(S);
3172 }
3173 
3175  Step S;
3177  S.Type = T;
3178  Steps.push_back(S);
3179 }
3180 
3182  Step S;
3183  S.Kind = SK_ArrayInit;
3184  S.Type = T;
3185  Steps.push_back(S);
3186 }
3187 
3189  Step S;
3191  S.Type = T;
3192  Steps.push_back(S);
3193 }
3194 
3196  bool shouldCopy) {
3197  Step s;
3198  s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
3200  s.Type = type;
3201  Steps.push_back(s);
3202 }
3203 
3205  Step S;
3207  S.Type = T;
3208  Steps.push_back(S);
3209 }
3210 
3212  Step S;
3214  S.Type = T;
3215  Steps.push_back(S);
3216 }
3217 
3219  Step S;
3220  S.Kind = SK_OCLSamplerInit;
3221  S.Type = T;
3222  Steps.push_back(S);
3223 }
3224 
3226  Step S;
3227  S.Kind = SK_OCLZeroEvent;
3228  S.Type = T;
3229  Steps.push_back(S);
3230 }
3231 
3233  InitListExpr *Syntactic) {
3234  assert(Syntactic->getNumInits() == 1 &&
3235  "Can only rewrap trivial init lists.");
3236  Step S;
3237  S.Kind = SK_UnwrapInitList;
3238  S.Type = Syntactic->getInit(0)->getType();
3239  Steps.insert(Steps.begin(), S);
3240 
3241  S.Kind = SK_RewrapInitList;
3242  S.Type = T;
3243  S.WrappingSyntacticList = Syntactic;
3244  Steps.push_back(S);
3245 }
3246 
3248  OverloadingResult Result) {
3250  this->Failure = Failure;
3251  this->FailedOverloadResult = Result;
3252 }
3253 
3254 //===----------------------------------------------------------------------===//
3255 // Attempt initialization
3256 //===----------------------------------------------------------------------===//
3257 
3258 /// Tries to add a zero initializer. Returns true if that worked.
3259 static bool
3261  const InitializedEntity &Entity) {
3262  if (Entity.getKind() != InitializedEntity::EK_Variable)
3263  return false;
3264 
3265  VarDecl *VD = cast<VarDecl>(Entity.getDecl());
3266  if (VD->getInit() || VD->getLocEnd().isMacroID())
3267  return false;
3268 
3269  QualType VariableTy = VD->getType().getCanonicalType();
3271  std::string Init = S.getFixItZeroInitializerForType(VariableTy, Loc);
3272  if (!Init.empty()) {
3273  Sequence.AddZeroInitializationStep(Entity.getType());
3274  Sequence.SetZeroInitializationFixit(Init, Loc);
3275  return true;
3276  }
3277  return false;
3278 }
3279 
3281  InitializationSequence &Sequence,
3282  const InitializedEntity &Entity) {
3283  if (!S.getLangOpts().ObjCAutoRefCount) return;
3284 
3285  /// When initializing a parameter, produce the value if it's marked
3286  /// __attribute__((ns_consumed)).
3287  if (Entity.isParameterKind()) {
3288  if (!Entity.isParameterConsumed())
3289  return;
3290 
3291  assert(Entity.getType()->isObjCRetainableType() &&
3292  "consuming an object of unretainable type?");
3293  Sequence.AddProduceObjCObjectStep(Entity.getType());
3294 
3295  /// When initializing a return value, if the return type is a
3296  /// retainable type, then returns need to immediately retain the
3297  /// object. If an autorelease is required, it will be done at the
3298  /// last instant.
3299  } else if (Entity.getKind() == InitializedEntity::EK_Result) {
3300  if (!Entity.getType()->isObjCRetainableType())
3301  return;
3302 
3303  Sequence.AddProduceObjCObjectStep(Entity.getType());
3304  }
3305 }
3306 
3307 static void TryListInitialization(Sema &S,
3308  const InitializedEntity &Entity,
3309  const InitializationKind &Kind,
3310  InitListExpr *InitList,
3311  InitializationSequence &Sequence);
3312 
3313 /// \brief When initializing from init list via constructor, handle
3314 /// initialization of an object of type std::initializer_list<T>.
3315 ///
3316 /// \return true if we have handled initialization of an object of type
3317 /// std::initializer_list<T>, false otherwise.
3319  InitListExpr *List,
3320  QualType DestType,
3321  InitializationSequence &Sequence) {
3322  QualType E;
3323  if (!S.isStdInitializerList(DestType, &E))
3324  return false;
3325 
3326  if (S.RequireCompleteType(List->getExprLoc(), E, 0)) {
3327  Sequence.setIncompleteTypeFailure(E);
3328  return true;
3329  }
3330 
3331  // Try initializing a temporary array from the init list.
3333  E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
3334  List->getNumInits()),
3336  InitializedEntity HiddenArray =
3338  InitializationKind Kind =
3340  TryListInitialization(S, HiddenArray, Kind, List, Sequence);
3341  if (Sequence)
3342  Sequence.AddStdInitializerListConstructionStep(DestType);
3343  return true;
3344 }
3345 
3346 static OverloadingResult
3348  MultiExprArg Args,
3349  OverloadCandidateSet &CandidateSet,
3352  bool CopyInitializing, bool AllowExplicit,
3353  bool OnlyListConstructors, bool IsListInit) {
3354  CandidateSet.clear();
3355 
3356  for (NamedDecl *D : Ctors) {
3357  DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3358  bool SuppressUserConversions = false;
3359 
3360  // Find the constructor (which may be a template).
3361  CXXConstructorDecl *Constructor = nullptr;
3362  FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
3363  if (ConstructorTmpl)
3364  Constructor = cast<CXXConstructorDecl>(
3365  ConstructorTmpl->getTemplatedDecl());
3366  else {
3367  Constructor = cast<CXXConstructorDecl>(D);
3368 
3369  // C++11 [over.best.ics]p4:
3370  // ... and the constructor or user-defined conversion function is a
3371  // candidate by
3372  // - 13.3.1.3, when the argument is the temporary in the second step
3373  // of a class copy-initialization, or
3374  // - 13.3.1.4, 13.3.1.5, or 13.3.1.6 (in all cases),
3375  // user-defined conversion sequences are not considered.
3376  // FIXME: This breaks backward compatibility, e.g. PR12117. As a
3377  // temporary fix, let's re-instate the third bullet above until
3378  // there is a resolution in the standard, i.e.,
3379  // - 13.3.1.7 when the initializer list has exactly one element that is
3380  // itself an initializer list and a conversion to some class X or
3381  // reference to (possibly cv-qualified) X is considered for the first
3382  // parameter of a constructor of X.
3383  if ((CopyInitializing ||
3384  (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
3385  Constructor->isCopyOrMoveConstructor())
3386  SuppressUserConversions = true;
3387  }
3388 
3389  if (!Constructor->isInvalidDecl() &&
3390  (AllowExplicit || !Constructor->isExplicit()) &&
3391  (!OnlyListConstructors || S.isInitListConstructor(Constructor))) {
3392  if (ConstructorTmpl)
3393  S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3394  /*ExplicitArgs*/ nullptr, Args,
3395  CandidateSet, SuppressUserConversions);
3396  else {
3397  // C++ [over.match.copy]p1:
3398  // - When initializing a temporary to be bound to the first parameter
3399  // of a constructor that takes a reference to possibly cv-qualified
3400  // T as its first argument, called with a single argument in the
3401  // context of direct-initialization, explicit conversion functions
3402  // are also considered.
3403  bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
3404  Args.size() == 1 &&
3405  Constructor->isCopyOrMoveConstructor();
3406  S.AddOverloadCandidate(Constructor, FoundDecl, Args, CandidateSet,
3407  SuppressUserConversions,
3408  /*PartialOverloading=*/false,
3409  /*AllowExplicit=*/AllowExplicitConv);
3410  }
3411  }
3412  }
3413 
3414  // Perform overload resolution and return the result.
3415  return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3416 }
3417 
3418 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3419 /// enumerates the constructors of the initialized entity and performs overload
3420 /// resolution to select the best.
3421 /// \param IsListInit Is this list-initialization?
3422 /// \param IsInitListCopy Is this non-list-initialization resulting from a
3423 /// list-initialization from {x} where x is the same
3424 /// type as the entity?
3426  const InitializedEntity &Entity,
3427  const InitializationKind &Kind,
3428  MultiExprArg Args, QualType DestType,
3429  InitializationSequence &Sequence,
3430  bool IsListInit = false,
3431  bool IsInitListCopy = false) {
3432  assert((!IsListInit || (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
3433  "IsListInit must come with a single initializer list argument.");
3434 
3435  // The type we're constructing needs to be complete.
3436  if (S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
3437  Sequence.setIncompleteTypeFailure(DestType);
3438  return;
3439  }
3440 
3441  const RecordType *DestRecordType = DestType->getAs<RecordType>();
3442  assert(DestRecordType && "Constructor initialization requires record type");
3443  CXXRecordDecl *DestRecordDecl
3444  = cast<CXXRecordDecl>(DestRecordType->getDecl());
3445 
3446  // Build the candidate set directly in the initialization sequence
3447  // structure, so that it will persist if we fail.
3448  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3449 
3450  // Determine whether we are allowed to call explicit constructors or
3451  // explicit conversion operators.
3452  bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
3453  bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
3454 
3455  // - Otherwise, if T is a class type, constructors are considered. The
3456  // applicable constructors are enumerated, and the best one is chosen
3457  // through overload resolution.
3458  DeclContext::lookup_result Ctors = S.LookupConstructors(DestRecordDecl);
3459 
3462  bool AsInitializerList = false;
3463 
3464  // C++11 [over.match.list]p1, per DR1467:
3465  // When objects of non-aggregate type T are list-initialized, such that
3466  // 8.5.4 [dcl.init.list] specifies that overload resolution is performed
3467  // according to the rules in this section, overload resolution selects
3468  // the constructor in two phases:
3469  //
3470  // - Initially, the candidate functions are the initializer-list
3471  // constructors of the class T and the argument list consists of the
3472  // initializer list as a single argument.
3473  if (IsListInit) {
3474  InitListExpr *ILE = cast<InitListExpr>(Args[0]);
3475  AsInitializerList = true;
3476 
3477  // If the initializer list has no elements and T has a default constructor,
3478  // the first phase is omitted.
3479  if (ILE->getNumInits() != 0 || !DestRecordDecl->hasDefaultConstructor())
3480  Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3481  CandidateSet, Ctors, Best,
3482  CopyInitialization, AllowExplicit,
3483  /*OnlyListConstructor=*/true,
3484  IsListInit);
3485 
3486  // Time to unwrap the init list.
3487  Args = MultiExprArg(ILE->getInits(), ILE->getNumInits());
3488  }
3489 
3490  // C++11 [over.match.list]p1:
3491  // - If no viable initializer-list constructor is found, overload resolution
3492  // is performed again, where the candidate functions are all the
3493  // constructors of the class T and the argument list consists of the
3494  // elements of the initializer list.
3495  if (Result == OR_No_Viable_Function) {
3496  AsInitializerList = false;
3497  Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3498  CandidateSet, Ctors, Best,
3499  CopyInitialization, AllowExplicit,
3500  /*OnlyListConstructors=*/false,
3501  IsListInit);
3502  }
3503  if (Result) {
3504  Sequence.SetOverloadFailure(IsListInit ?
3507  Result);
3508  return;
3509  }
3510 
3511  // C++11 [dcl.init]p6:
3512  // If a program calls for the default initialization of an object
3513  // of a const-qualified type T, T shall be a class type with a
3514  // user-provided default constructor.
3515  if (Kind.getKind() == InitializationKind::IK_Default &&
3516  Entity.getType().isConstQualified() &&
3517  !cast<CXXConstructorDecl>(Best->Function)->isUserProvided()) {
3518  if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
3520  return;
3521  }
3522 
3523  // C++11 [over.match.list]p1:
3524  // In copy-list-initialization, if an explicit constructor is chosen, the
3525  // initializer is ill-formed.
3526  CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3527  if (IsListInit && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3529  return;
3530  }
3531 
3532  // Add the constructor initialization step. Any cv-qualification conversion is
3533  // subsumed by the initialization.
3534  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3536  CtorDecl, Best->FoundDecl.getAccess(), DestType, HadMultipleCandidates,
3537  IsListInit | IsInitListCopy, AsInitializerList);
3538 }
3539 
3540 static bool
3542  Expr *Initializer,
3543  QualType &SourceType,
3544  QualType &UnqualifiedSourceType,
3545  QualType UnqualifiedTargetType,
3546  InitializationSequence &Sequence) {
3547  if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
3548  S.Context.OverloadTy) {
3549  DeclAccessPair Found;
3550  bool HadMultipleCandidates = false;
3551  if (FunctionDecl *Fn
3552  = S.ResolveAddressOfOverloadedFunction(Initializer,
3553  UnqualifiedTargetType,
3554  false, Found,
3555  &HadMultipleCandidates)) {
3556  Sequence.AddAddressOverloadResolutionStep(Fn, Found,
3557  HadMultipleCandidates);
3558  SourceType = Fn->getType();
3559  UnqualifiedSourceType = SourceType.getUnqualifiedType();
3560  } else if (!UnqualifiedTargetType->isRecordType()) {
3562  return true;
3563  }
3564  }
3565  return false;
3566 }
3567 
3568 static void TryReferenceInitializationCore(Sema &S,
3569  const InitializedEntity &Entity,
3570  const InitializationKind &Kind,
3571  Expr *Initializer,
3572  QualType cv1T1, QualType T1,
3573  Qualifiers T1Quals,
3574  QualType cv2T2, QualType T2,
3575  Qualifiers T2Quals,
3576  InitializationSequence &Sequence);
3577 
3578 static void TryValueInitialization(Sema &S,
3579  const InitializedEntity &Entity,
3580  const InitializationKind &Kind,
3581  InitializationSequence &Sequence,
3582  InitListExpr *InitList = nullptr);
3583 
3584 /// \brief Attempt list initialization of a reference.
3586  const InitializedEntity &Entity,
3587  const InitializationKind &Kind,
3588  InitListExpr *InitList,
3589  InitializationSequence &Sequence) {
3590  // First, catch C++03 where this isn't possible.
3591  if (!S.getLangOpts().CPlusPlus11) {
3593  return;
3594  }
3595  // Can't reference initialize a compound literal.
3598  return;
3599  }
3600 
3601  QualType DestType = Entity.getType();
3602  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3603  Qualifiers T1Quals;
3604  QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3605 
3606  // Reference initialization via an initializer list works thus:
3607  // If the initializer list consists of a single element that is
3608  // reference-related to the referenced type, bind directly to that element
3609  // (possibly creating temporaries).
3610  // Otherwise, initialize a temporary with the initializer list and
3611  // bind to that.
3612  if (InitList->getNumInits() == 1) {
3613  Expr *Initializer = InitList->getInit(0);
3614  QualType cv2T2 = Initializer->getType();
3615  Qualifiers T2Quals;
3616  QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3617 
3618  // If this fails, creating a temporary wouldn't work either.
3619  if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3620  T1, Sequence))
3621  return;
3622 
3623  SourceLocation DeclLoc = Initializer->getLocStart();
3624  bool dummy1, dummy2, dummy3;
3625  Sema::ReferenceCompareResult RefRelationship
3626  = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3627  dummy2, dummy3);
3628  if (RefRelationship >= Sema::Ref_Related) {
3629  // Try to bind the reference here.
3630  TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3631  T1Quals, cv2T2, T2, T2Quals, Sequence);
3632  if (Sequence)
3633  Sequence.RewrapReferenceInitList(cv1T1, InitList);
3634  return;
3635  }
3636 
3637  // Update the initializer if we've resolved an overloaded function.
3638  if (Sequence.step_begin() != Sequence.step_end())
3639  Sequence.RewrapReferenceInitList(cv1T1, InitList);
3640  }
3641 
3642  // Not reference-related. Create a temporary and bind to that.
3644 
3645  TryListInitialization(S, TempEntity, Kind, InitList, Sequence);
3646  if (Sequence) {
3647  if (DestType->isRValueReferenceType() ||
3648  (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3649  Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3650  else
3651  Sequence.SetFailed(
3653  }
3654 }
3655 
3656 /// \brief Attempt list initialization (C++0x [dcl.init.list])
3658  const InitializedEntity &Entity,
3659  const InitializationKind &Kind,
3660  InitListExpr *InitList,
3661  InitializationSequence &Sequence) {
3662  QualType DestType = Entity.getType();
3663 
3664  // C++ doesn't allow scalar initialization with more than one argument.
3665  // But C99 complex numbers are scalars and it makes sense there.
3666  if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
3667  !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
3669  return;
3670  }
3671  if (DestType->isReferenceType()) {
3672  TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence);
3673  return;
3674  }
3675 
3676  if (DestType->isRecordType() &&
3677  S.RequireCompleteType(InitList->getLocStart(), DestType, 0)) {
3678  Sequence.setIncompleteTypeFailure(DestType);
3679  return;
3680  }
3681 
3682  // C++11 [dcl.init.list]p3, per DR1467:
3683  // - If T is a class type and the initializer list has a single element of
3684  // type cv U, where U is T or a class derived from T, the object is
3685  // initialized from that element (by copy-initialization for
3686  // copy-list-initialization, or by direct-initialization for
3687  // direct-list-initialization).
3688  // - Otherwise, if T is a character array and the initializer list has a
3689  // single element that is an appropriately-typed string literal
3690  // (8.5.2 [dcl.init.string]), initialization is performed as described
3691  // in that section.
3692  // - Otherwise, if T is an aggregate, [...] (continue below).
3693  if (S.getLangOpts().CPlusPlus11 && InitList->getNumInits() == 1) {
3694  if (DestType->isRecordType()) {
3695  QualType InitType = InitList->getInit(0)->getType();
3696  if (S.Context.hasSameUnqualifiedType(InitType, DestType) ||
3697  S.IsDerivedFrom(InitType, DestType)) {
3698  Expr *InitAsExpr = InitList->getInit(0);
3699  TryConstructorInitialization(S, Entity, Kind, InitAsExpr, DestType,
3700  Sequence, /*InitListSyntax*/ false,
3701  /*IsInitListCopy*/ true);
3702  return;
3703  }
3704  }
3705  if (const ArrayType *DestAT = S.Context.getAsArrayType(DestType)) {
3706  Expr *SubInit[1] = {InitList->getInit(0)};
3707  if (!isa<VariableArrayType>(DestAT) &&
3708  IsStringInit(SubInit[0], DestAT, S.Context) == SIF_None) {
3709  InitializationKind SubKind =
3712  InitList->getLBraceLoc(),
3713  InitList->getRBraceLoc())
3714  : Kind;
3715  Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3716  /*TopLevelOfInitList*/ true);
3717 
3718  // TryStringLiteralInitialization() (in InitializeFrom()) will fail if
3719  // the element is not an appropriately-typed string literal, in which
3720  // case we should proceed as in C++11 (below).
3721  if (Sequence) {
3722  Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3723  return;
3724  }
3725  }
3726  }
3727  }
3728 
3729  // C++11 [dcl.init.list]p3:
3730  // - If T is an aggregate, aggregate initialization is performed.
3731  if (DestType->isRecordType() && !DestType->isAggregateType()) {
3732  if (S.getLangOpts().CPlusPlus11) {
3733  // - Otherwise, if the initializer list has no elements and T is a
3734  // class type with a default constructor, the object is
3735  // value-initialized.
3736  if (InitList->getNumInits() == 0) {
3737  CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
3738  if (RD->hasDefaultConstructor()) {
3739  TryValueInitialization(S, Entity, Kind, Sequence, InitList);
3740  return;
3741  }
3742  }
3743 
3744  // - Otherwise, if T is a specialization of std::initializer_list<E>,
3745  // an initializer_list object constructed [...]
3746  if (TryInitializerListConstruction(S, InitList, DestType, Sequence))
3747  return;
3748 
3749  // - Otherwise, if T is a class type, constructors are considered.
3750  Expr *InitListAsExpr = InitList;
3751  TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
3752  Sequence, /*InitListSyntax*/ true);
3753  } else
3755  return;
3756  }
3757 
3758  if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() &&
3759  InitList->getNumInits() == 1 &&
3760  InitList->getInit(0)->getType()->isRecordType()) {
3761  // - Otherwise, if the initializer list has a single element of type E
3762  // [...references are handled above...], the object or reference is
3763  // initialized from that element (by copy-initialization for
3764  // copy-list-initialization, or by direct-initialization for
3765  // direct-list-initialization); if a narrowing conversion is required
3766  // to convert the element to T, the program is ill-formed.
3767  //
3768  // Per core-24034, this is direct-initialization if we were performing
3769  // direct-list-initialization and copy-initialization otherwise.
3770  // We can't use InitListChecker for this, because it always performs
3771  // copy-initialization. This only matters if we might use an 'explicit'
3772  // conversion operator, so we only need to handle the cases where the source
3773  // is of record type.
3774  InitializationKind SubKind =
3777  InitList->getLBraceLoc(),
3778  InitList->getRBraceLoc())
3779  : Kind;
3780  Expr *SubInit[1] = { InitList->getInit(0) };
3781  Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3782  /*TopLevelOfInitList*/true);
3783  if (Sequence)
3784  Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3785  return;
3786  }
3787 
3788  InitListChecker CheckInitList(S, Entity, InitList,
3789  DestType, /*VerifyOnly=*/true);
3790  if (CheckInitList.HadError()) {
3792  return;
3793  }
3794 
3795  // Add the list initialization step with the built init list.
3796  Sequence.AddListInitializationStep(DestType);
3797 }
3798 
3799 /// \brief Try a reference initialization that involves calling a conversion
3800 /// function.
3802  const InitializedEntity &Entity,
3803  const InitializationKind &Kind,
3804  Expr *Initializer,
3805  bool AllowRValues,
3806  InitializationSequence &Sequence) {
3807  QualType DestType = Entity.getType();
3808  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3809  QualType T1 = cv1T1.getUnqualifiedType();
3810  QualType cv2T2 = Initializer->getType();
3811  QualType T2 = cv2T2.getUnqualifiedType();
3812 
3813  bool DerivedToBase;
3814  bool ObjCConversion;
3815  bool ObjCLifetimeConversion;
3816  assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
3817  T1, T2, DerivedToBase,
3818  ObjCConversion,
3819  ObjCLifetimeConversion) &&
3820  "Must have incompatible references when binding via conversion");
3821  (void)DerivedToBase;
3822  (void)ObjCConversion;
3823  (void)ObjCLifetimeConversion;
3824 
3825  // Build the candidate set directly in the initialization sequence
3826  // structure, so that it will persist if we fail.
3827  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3828  CandidateSet.clear();
3829 
3830  // Determine whether we are allowed to call explicit constructors or
3831  // explicit conversion operators.
3832  bool AllowExplicit = Kind.AllowExplicit();
3833  bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
3834 
3835  const RecordType *T1RecordType = nullptr;
3836  if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
3837  !S.RequireCompleteType(Kind.getLocation(), T1, 0)) {
3838  // The type we're converting to is a class type. Enumerate its constructors
3839  // to see if there is a suitable conversion.
3840  CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
3841 
3842  for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) {
3843  DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3844 
3845  // Find the constructor (which may be a template).
3846  CXXConstructorDecl *Constructor = nullptr;
3847  FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
3848  if (ConstructorTmpl)
3849  Constructor = cast<CXXConstructorDecl>(
3850  ConstructorTmpl->getTemplatedDecl());
3851  else
3852  Constructor = cast<CXXConstructorDecl>(D);
3853 
3854  if (!Constructor->isInvalidDecl() &&
3855  Constructor->isConvertingConstructor(AllowExplicit)) {
3856  if (ConstructorTmpl)
3857  S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3858  /*ExplicitArgs*/ nullptr,
3859  Initializer, CandidateSet,
3860  /*SuppressUserConversions=*/true);
3861  else
3862  S.AddOverloadCandidate(Constructor, FoundDecl,
3863  Initializer, CandidateSet,
3864  /*SuppressUserConversions=*/true);
3865  }
3866  }
3867  }
3868  if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
3869  return OR_No_Viable_Function;
3870 
3871  const RecordType *T2RecordType = nullptr;
3872  if ((T2RecordType = T2->getAs<RecordType>()) &&
3873  !S.RequireCompleteType(Kind.getLocation(), T2, 0)) {
3874  // The type we're converting from is a class type, enumerate its conversion
3875  // functions.
3876  CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
3877 
3878  const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
3879  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3880  NamedDecl *D = *I;
3881  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3882  if (isa<UsingShadowDecl>(D))
3883  D = cast<UsingShadowDecl>(D)->getTargetDecl();
3884 
3885  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
3886  CXXConversionDecl *Conv;
3887  if (ConvTemplate)
3888  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3889  else
3890  Conv = cast<CXXConversionDecl>(D);
3891 
3892  // If the conversion function doesn't return a reference type,
3893  // it can't be considered for this conversion unless we're allowed to
3894  // consider rvalues.
3895  // FIXME: Do we need to make sure that we only consider conversion
3896  // candidates with reference-compatible results? That might be needed to
3897  // break recursion.
3898  if ((AllowExplicitConvs || !Conv->isExplicit()) &&
3899  (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
3900  if (ConvTemplate)
3901  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
3902  ActingDC, Initializer,
3903  DestType, CandidateSet,
3904  /*AllowObjCConversionOnExplicit=*/
3905  false);
3906  else
3907  S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
3908  Initializer, DestType, CandidateSet,
3909  /*AllowObjCConversionOnExplicit=*/false);
3910  }
3911  }
3912  }
3913  if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
3914  return OR_No_Viable_Function;
3915 
3916  SourceLocation DeclLoc = Initializer->getLocStart();
3917 
3918  // Perform overload resolution. If it fails, return the failed result.
3920  if (OverloadingResult Result
3921  = CandidateSet.BestViableFunction(S, DeclLoc, Best, true))
3922  return Result;
3923 
3924  FunctionDecl *Function = Best->Function;
3925  // This is the overload that will be used for this initialization step if we
3926  // use this initialization. Mark it as referenced.
3927  Function->setReferenced();
3928 
3929  // Compute the returned type of the conversion.
3930  if (isa<CXXConversionDecl>(Function))
3931  T2 = Function->getReturnType();
3932  else
3933  T2 = cv1T1;
3934 
3935  // Add the user-defined conversion step.
3936  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3937  Sequence.AddUserConversionStep(Function, Best->FoundDecl,
3938  T2.getNonLValueExprType(S.Context),
3939  HadMultipleCandidates);
3940 
3941  // Determine whether we need to perform derived-to-base or
3942  // cv-qualification adjustments.
3943  ExprValueKind VK = VK_RValue;
3944  if (T2->isLValueReferenceType())
3945  VK = VK_LValue;
3946  else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>())
3947  VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
3948 
3949  bool NewDerivedToBase = false;
3950  bool NewObjCConversion = false;
3951  bool NewObjCLifetimeConversion = false;
3952  Sema::ReferenceCompareResult NewRefRelationship
3953  = S.CompareReferenceRelationship(DeclLoc, T1,
3955  NewDerivedToBase, NewObjCConversion,
3956  NewObjCLifetimeConversion);
3957  if (NewRefRelationship == Sema::Ref_Incompatible) {
3958  // If the type we've converted to is not reference-related to the
3959  // type we're looking for, then there is another conversion step
3960  // we need to perform to produce a temporary of the right type
3961  // that we'll be binding to.
3963  ICS.setStandard();
3964  ICS.Standard = Best->FinalConversion;
3965  T2 = ICS.Standard.getToType(2);
3966  Sequence.AddConversionSequenceStep(ICS, T2);
3967  } else if (NewDerivedToBase)
3968  Sequence.AddDerivedToBaseCastStep(
3971  VK);
3972  else if (NewObjCConversion)
3973  Sequence.AddObjCObjectConversionStep(
3976 
3977  if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers())
3978  Sequence.AddQualificationConversionStep(cv1T1, VK);
3979 
3980  Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType());
3981  return OR_Success;
3982 }
3983 
3984 static void CheckCXX98CompatAccessibleCopy(Sema &S,
3985  const InitializedEntity &Entity,
3986  Expr *CurInitExpr);
3987 
3988 /// \brief Attempt reference initialization (C++0x [dcl.init.ref])
3990  const InitializedEntity &Entity,
3991  const InitializationKind &Kind,
3992  Expr *Initializer,
3993  InitializationSequence &Sequence) {
3994  QualType DestType = Entity.getType();
3995  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3996  Qualifiers T1Quals;
3997  QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3998  QualType cv2T2 = Initializer->getType();
3999  Qualifiers T2Quals;
4000  QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
4001 
4002  // If the initializer is the address of an overloaded function, try
4003  // to resolve the overloaded function. If all goes well, T2 is the
4004  // type of the resulting function.
4005  if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
4006  T1, Sequence))
4007  return;
4008 
4009  // Delegate everything else to a subfunction.
4010  TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
4011  T1Quals, cv2T2, T2, T2Quals, Sequence);
4012 }
4013 
4014 /// Converts the target of reference initialization so that it has the
4015 /// appropriate qualifiers and value kind.
4016 ///
4017 /// In this case, 'x' is an 'int' lvalue, but it needs to be 'const int'.
4018 /// \code
4019 /// int x;
4020 /// const int &r = x;
4021 /// \endcode
4022 ///
4023 /// In this case the reference is binding to a bitfield lvalue, which isn't
4024 /// valid. Perform a load to create a lifetime-extended temporary instead.
4025 /// \code
4026 /// const int &r = someStruct.bitfield;
4027 /// \endcode
4028 static ExprValueKind
4030  InitializationSequence &Sequence,
4031  Expr *Initializer,
4032  QualType cv1T1,
4033  Qualifiers T1Quals,
4034  Qualifiers T2Quals,
4035  bool IsLValueRef) {
4036  bool IsNonAddressableType = Initializer->refersToBitField() ||
4037  Initializer->refersToVectorElement();
4038 
4039  if (IsNonAddressableType) {
4040  // C++11 [dcl.init.ref]p5: [...] Otherwise, the reference shall be an
4041  // lvalue reference to a non-volatile const type, or the reference shall be
4042  // an rvalue reference.
4043  //
4044  // If not, we can't make a temporary and bind to that. Give up and allow the
4045  // error to be diagnosed later.
4046  if (IsLValueRef && (!T1Quals.hasConst() || T1Quals.hasVolatile())) {
4047  assert(Initializer->isGLValue());
4048  return Initializer->getValueKind();
4049  }
4050 
4051  // Force a load so we can materialize a temporary.
4052  Sequence.AddLValueToRValueStep(cv1T1.getUnqualifiedType());
4053  return VK_RValue;
4054  }
4055 
4056  if (T1Quals != T2Quals) {
4057  Sequence.AddQualificationConversionStep(cv1T1,
4058  Initializer->getValueKind());
4059  }
4060 
4061  return Initializer->getValueKind();
4062 }
4063 
4064 
4065 /// \brief Reference initialization without resolving overloaded functions.
4067  const InitializedEntity &Entity,
4068  const InitializationKind &Kind,
4069  Expr *Initializer,
4070  QualType cv1T1, QualType T1,
4071  Qualifiers T1Quals,
4072  QualType cv2T2, QualType T2,
4073  Qualifiers T2Quals,
4074  InitializationSequence &Sequence) {
4075  QualType DestType = Entity.getType();
4076  SourceLocation DeclLoc = Initializer->getLocStart();
4077  // Compute some basic properties of the types and the initializer.
4078  bool isLValueRef = DestType->isLValueReferenceType();
4079  bool isRValueRef = !isLValueRef;
4080  bool DerivedToBase = false;
4081  bool ObjCConversion = false;
4082  bool ObjCLifetimeConversion = false;
4083  Expr::Classification InitCategory = Initializer->Classify(S.Context);
4084  Sema::ReferenceCompareResult RefRelationship
4085  = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
4086  ObjCConversion, ObjCLifetimeConversion);
4087 
4088  // C++0x [dcl.init.ref]p5:
4089  // A reference to type "cv1 T1" is initialized by an expression of type
4090  // "cv2 T2" as follows:
4091  //
4092  // - If the reference is an lvalue reference and the initializer
4093  // expression
4094  // Note the analogous bullet points for rvalue refs to functions. Because
4095  // there are no function rvalues in C++, rvalue refs to functions are treated
4096  // like lvalue refs.
4097  OverloadingResult ConvOvlResult = OR_Success;
4098  bool T1Function = T1->isFunctionType();
4099  if (isLValueRef || T1Function) {
4100  if (InitCategory.isLValue() &&
4101  (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
4102  (Kind.isCStyleOrFunctionalCast() &&
4103  RefRelationship == Sema::Ref_Related))) {
4104  // - is an lvalue (but is not a bit-field), and "cv1 T1" is
4105  // reference-compatible with "cv2 T2," or
4106  //
4107  // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a
4108  // bit-field when we're determining whether the reference initialization
4109  // can occur. However, we do pay attention to whether it is a bit-field
4110  // to decide whether we're actually binding to a temporary created from
4111  // the bit-field.
4112  if (DerivedToBase)
4113  Sequence.AddDerivedToBaseCastStep(
4114  S.Context.getQualifiedType(T1, T2Quals),
4115  VK_LValue);
4116  else if (ObjCConversion)
4117  Sequence.AddObjCObjectConversionStep(
4118  S.Context.getQualifiedType(T1, T2Quals));
4119 
4120  ExprValueKind ValueKind =
4121  convertQualifiersAndValueKindIfNecessary(S, Sequence, Initializer,
4122  cv1T1, T1Quals, T2Quals,
4123  isLValueRef);
4124  Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
4125  return;
4126  }
4127 
4128  // - has a class type (i.e., T2 is a class type), where T1 is not
4129  // reference-related to T2, and can be implicitly converted to an
4130  // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
4131  // with "cv3 T3" (this conversion is selected by enumerating the
4132  // applicable conversion functions (13.3.1.6) and choosing the best
4133  // one through overload resolution (13.3)),
4134  // If we have an rvalue ref to function type here, the rhs must be
4135  // an rvalue. DR1287 removed the "implicitly" here.
4136  if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
4137  (isLValueRef || InitCategory.isRValue())) {
4138  ConvOvlResult = TryRefInitWithConversionFunction(
4139  S, Entity, Kind, Initializer, /*AllowRValues*/isRValueRef, Sequence);
4140  if (ConvOvlResult == OR_Success)
4141  return;
4142  if (ConvOvlResult != OR_No_Viable_Function)
4143  Sequence.SetOverloadFailure(
4145  ConvOvlResult);
4146  }
4147  }
4148 
4149  // - Otherwise, the reference shall be an lvalue reference to a
4150  // non-volatile const type (i.e., cv1 shall be const), or the reference
4151  // shall be an rvalue reference.
4152  if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
4153  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4155  else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4156  Sequence.SetOverloadFailure(
4158  ConvOvlResult);
4159  else
4160  Sequence.SetFailed(InitCategory.isLValue()
4161  ? (RefRelationship == Sema::Ref_Related
4165 
4166  return;
4167  }
4168 
4169  // - If the initializer expression
4170  // - is an xvalue, class prvalue, array prvalue, or function lvalue and
4171  // "cv1 T1" is reference-compatible with "cv2 T2"
4172  // Note: functions are handled below.
4173  if (!T1Function &&
4174  (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
4175  (Kind.isCStyleOrFunctionalCast() &&
4176  RefRelationship == Sema::Ref_Related)) &&
4177  (InitCategory.isXValue() ||
4178  (InitCategory.isPRValue() && T2->isRecordType()) ||
4179  (InitCategory.isPRValue() && T2->isArrayType()))) {
4180  ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue;
4181  if (InitCategory.isPRValue() && T2->isRecordType()) {
4182  // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
4183  // compiler the freedom to perform a copy here or bind to the
4184  // object, while C++0x requires that we bind directly to the
4185  // object. Hence, we always bind to the object without making an
4186  // extra copy. However, in C++03 requires that we check for the
4187  // presence of a suitable copy constructor:
4188  //
4189  // The constructor that would be used to make the copy shall
4190  // be callable whether or not the copy is actually done.
4191  if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
4192  Sequence.AddExtraneousCopyToTemporary(cv2T2);
4193  else if (S.getLangOpts().CPlusPlus11)
4194  CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
4195  }
4196 
4197  if (DerivedToBase)
4198  Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals),
4199  ValueKind);
4200  else if (ObjCConversion)
4201  Sequence.AddObjCObjectConversionStep(
4202  S.Context.getQualifiedType(T1, T2Quals));
4203 
4204  ValueKind = convertQualifiersAndValueKindIfNecessary(S, Sequence,
4205  Initializer, cv1T1,
4206  T1Quals, T2Quals,
4207  isLValueRef);
4208 
4209  Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
4210  return;
4211  }
4212 
4213  // - has a class type (i.e., T2 is a class type), where T1 is not
4214  // reference-related to T2, and can be implicitly converted to an
4215  // xvalue, class prvalue, or function lvalue of type "cv3 T3",
4216  // where "cv1 T1" is reference-compatible with "cv3 T3",
4217  //
4218  // DR1287 removes the "implicitly" here.
4219  if (T2->isRecordType()) {
4220  if (RefRelationship == Sema::Ref_Incompatible) {
4221  ConvOvlResult = TryRefInitWithConversionFunction(
4222  S, Entity, Kind, Initializer, /*AllowRValues*/true, Sequence);
4223  if (ConvOvlResult)
4224  Sequence.SetOverloadFailure(
4226  ConvOvlResult);
4227 
4228  return;
4229  }
4230 
4231  if ((RefRelationship == Sema::Ref_Compatible ||
4232  RefRelationship == Sema::Ref_Compatible_With_Added_Qualification) &&
4233  isRValueRef && InitCategory.isLValue()) {
4234  Sequence.SetFailed(
4236  return;
4237  }
4238 
4240  return;
4241  }
4242 
4243  // - Otherwise, a temporary of type "cv1 T1" is created and initialized
4244  // from the initializer expression using the rules for a non-reference
4245  // copy-initialization (8.5). The reference is then bound to the
4246  // temporary. [...]
4247 
4249 
4250  // FIXME: Why do we use an implicit conversion here rather than trying
4251  // copy-initialization?
4253  = S.TryImplicitConversion(Initializer, TempEntity.getType(),
4254  /*SuppressUserConversions=*/false,
4255  /*AllowExplicit=*/false,
4256  /*FIXME:InOverloadResolution=*/false,
4257  /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4258  /*AllowObjCWritebackConversion=*/false);
4259 
4260  if (ICS.isBad()) {
4261  // FIXME: Use the conversion function set stored in ICS to turn
4262  // this into an overloading ambiguity diagnostic. However, we need
4263  // to keep that set as an OverloadCandidateSet rather than as some
4264  // other kind of set.
4265  if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4266  Sequence.SetOverloadFailure(
4268  ConvOvlResult);
4269  else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4271  else
4273  return;
4274  } else {
4275  Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
4276  }
4277 
4278  // [...] If T1 is reference-related to T2, cv1 must be the
4279  // same cv-qualification as, or greater cv-qualification
4280  // than, cv2; otherwise, the program is ill-formed.
4281  unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
4282  unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
4283  if (RefRelationship == Sema::Ref_Related &&
4284  (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
4286  return;
4287  }
4288 
4289  // [...] If T1 is reference-related to T2 and the reference is an rvalue
4290  // reference, the initializer expression shall not be an lvalue.
4291  if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
4292  InitCategory.isLValue()) {
4293  Sequence.SetFailed(
4295  return;
4296  }
4297 
4298  Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
4299  return;
4300 }
4301 
4302 /// \brief Attempt character array initialization from a string literal
4303 /// (C++ [dcl.init.string], C99 6.7.8).
4305  const InitializedEntity &Entity,
4306  const InitializationKind &Kind,
4307  Expr *Initializer,
4308  InitializationSequence &Sequence) {
4309  Sequence.AddStringInitStep(Entity.getType());
4310 }
4311 
4312 /// \brief Attempt value initialization (C++ [dcl.init]p7).
4314  const InitializedEntity &Entity,
4315  const InitializationKind &Kind,
4316  InitializationSequence &Sequence,
4317  InitListExpr *InitList) {
4318  assert((!InitList || InitList->getNumInits() == 0) &&
4319  "Shouldn't use value-init for non-empty init lists");
4320 
4321  // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
4322  //
4323  // To value-initialize an object of type T means:
4324  QualType T = Entity.getType();
4325 
4326  // -- if T is an array type, then each element is value-initialized;
4327  T = S.Context.getBaseElementType(T);
4328 
4329  if (const RecordType *RT = T->getAs<RecordType>()) {
4330  if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
4331  bool NeedZeroInitialization = true;
4332  if (!S.getLangOpts().CPlusPlus11) {
4333  // C++98:
4334  // -- if T is a class type (clause 9) with a user-declared constructor
4335  // (12.1), then the default constructor for T is called (and the
4336  // initialization is ill-formed if T has no accessible default
4337  // constructor);
4338  if (ClassDecl->hasUserDeclaredConstructor())
4339  NeedZeroInitialization = false;
4340  } else {
4341  // C++11:
4342  // -- if T is a class type (clause 9) with either no default constructor
4343  // (12.1 [class.ctor]) or a default constructor that is user-provided
4344  // or deleted, then the object is default-initialized;
4345  CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
4346  if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
4347  NeedZeroInitialization = false;
4348  }
4349 
4350  // -- if T is a (possibly cv-qualified) non-union class type without a
4351  // user-provided or deleted default constructor, then the object is
4352  // zero-initialized and, if T has a non-trivial default constructor,
4353  // default-initialized;
4354  // The 'non-union' here was removed by DR1502. The 'non-trivial default
4355  // constructor' part was removed by DR1507.
4356  if (NeedZeroInitialization)
4357  Sequence.AddZeroInitializationStep(Entity.getType());
4358 
4359  // C++03:
4360  // -- if T is a non-union class type without a user-declared constructor,
4361  // then every non-static data member and base class component of T is
4362  // value-initialized;
4363  // [...] A program that calls for [...] value-initialization of an
4364  // entity of reference type is ill-formed.
4365  //
4366  // C++11 doesn't need this handling, because value-initialization does not
4367  // occur recursively there, and the implicit default constructor is
4368  // defined as deleted in the problematic cases.
4369  if (!S.getLangOpts().CPlusPlus11 &&
4370  ClassDecl->hasUninitializedReferenceMember()) {
4372  return;
4373  }
4374 
4375  // If this is list-value-initialization, pass the empty init list on when
4376  // building the constructor call. This affects the semantics of a few
4377  // things (such as whether an explicit default constructor can be called).
4378  Expr *InitListAsExpr = InitList;
4379  MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
4380  bool InitListSyntax = InitList;
4381 
4382  return TryConstructorInitialization(S, Entity, Kind, Args, T, Sequence,
4383  InitListSyntax);
4384  }
4385  }
4386 
4387  Sequence.AddZeroInitializationStep(Entity.getType());
4388 }
4389 
4390 /// \brief Attempt default initialization (C++ [dcl.init]p6).
4392  const InitializedEntity &Entity,
4393  const InitializationKind &Kind,
4394  InitializationSequence &Sequence) {
4395  assert(Kind.getKind() == InitializationKind::IK_Default);
4396 
4397  // C++ [dcl.init]p6:
4398  // To default-initialize an object of type T means:
4399  // - if T is an array type, each element is default-initialized;
4400  QualType DestType = S.Context.getBaseElementType(Entity.getType());
4401 
4402  // - if T is a (possibly cv-qualified) class type (Clause 9), the default
4403  // constructor for T is called (and the initialization is ill-formed if
4404  // T has no accessible default constructor);
4405  if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
4406  TryConstructorInitialization(S, Entity, Kind, None, DestType, Sequence);
4407  return;
4408  }
4409 
4410  // - otherwise, no initialization is performed.
4411 
4412  // If a program calls for the default initialization of an object of
4413  // a const-qualified type T, T shall be a class type with a user-provided
4414  // default constructor.
4415  if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
4416  if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
4418  return;
4419  }
4420 
4421  // If the destination type has a lifetime property, zero-initialize it.
4422  if (DestType.getQualifiers().hasObjCLifetime()) {
4423  Sequence.AddZeroInitializationStep(Entity.getType());
4424  return;
4425  }
4426 }
4427 
4428 /// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
4429 /// which enumerates all conversion functions and performs overload resolution
4430 /// to select the best.
4432  QualType DestType,
4433  const InitializationKind &Kind,
4434  Expr *Initializer,
4435  InitializationSequence &Sequence,
4436  bool TopLevelOfInitList) {
4437  assert(!DestType->isReferenceType() && "References are handled elsewhere");
4438  QualType SourceType = Initializer->getType();
4439  assert((DestType->isRecordType() || SourceType->isRecordType()) &&
4440  "Must have a class type to perform a user-defined conversion");
4441 
4442  // Build the candidate set directly in the initialization sequence
4443  // structure, so that it will persist if we fail.
4444  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4445  CandidateSet.clear();
4446 
4447  // Determine whether we are allowed to call explicit constructors or
4448  // explicit conversion operators.
4449  bool AllowExplicit = Kind.AllowExplicit();
4450 
4451  if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4452  // The type we're converting to is a class type. Enumerate its constructors
4453  // to see if there is a suitable conversion.
4454  CXXRecordDecl *DestRecordDecl
4455  = cast<CXXRecordDecl>(DestRecordType->getDecl());
4456 
4457  // Try to complete the type we're converting to.
4458  if (!S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
4459  DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
4460  // The container holding the constructors can under certain conditions
4461  // be changed while iterating. To be safe we copy the lookup results
4462  // to a new container.
4463  SmallVector<NamedDecl*, 8> CopyOfCon(R.begin(), R.end());
4465  Con = CopyOfCon.begin(), ConEnd = CopyOfCon.end();
4466  Con != ConEnd; ++Con) {
4467  NamedDecl *D = *Con;
4468  DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
4469 
4470  // Find the constructor (which may be a template).
4471  CXXConstructorDecl *Constructor = nullptr;
4472  FunctionTemplateDecl *ConstructorTmpl
4473  = dyn_cast<FunctionTemplateDecl>(D);
4474  if (ConstructorTmpl)
4475  Constructor = cast<CXXConstructorDecl>(
4476  ConstructorTmpl->getTemplatedDecl());
4477  else
4478  Constructor = cast<CXXConstructorDecl>(D);
4479 
4480  if (!Constructor->isInvalidDecl() &&
4481  Constructor->isConvertingConstructor(AllowExplicit)) {
4482  if (ConstructorTmpl)
4483  S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
4484  /*ExplicitArgs*/ nullptr,
4485  Initializer, CandidateSet,
4486  /*SuppressUserConversions=*/true);
4487  else
4488  S.AddOverloadCandidate(Constructor, FoundDecl,
4489  Initializer, CandidateSet,
4490  /*SuppressUserConversions=*/true);
4491  }
4492  }
4493  }
4494  }
4495 
4496  SourceLocation DeclLoc = Initializer->getLocStart();
4497 
4498  if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
4499  // The type we're converting from is a class type, enumerate its conversion
4500  // functions.
4501 
4502  // We can only enumerate the conversion functions for a complete type; if
4503  // the type isn't complete, simply skip this step.
4504  if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) {
4505  CXXRecordDecl *SourceRecordDecl
4506  = cast<CXXRecordDecl>(SourceRecordType->getDecl());
4507 
4508  const auto &Conversions =
4509  SourceRecordDecl->getVisibleConversionFunctions();
4510  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4511  NamedDecl *D = *I;
4512  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4513  if (isa<UsingShadowDecl>(D))
4514  D = cast<UsingShadowDecl>(D)->getTargetDecl();
4515 
4516  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4517  CXXConversionDecl *Conv;
4518  if (ConvTemplate)
4519  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4520  else
4521  Conv = cast<CXXConversionDecl>(D);
4522 
4523  if (AllowExplicit || !Conv->isExplicit()) {
4524  if (ConvTemplate)
4525  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4526  ActingDC, Initializer, DestType,
4527  CandidateSet, AllowExplicit);
4528  else
4529  S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4530  Initializer, DestType, CandidateSet,
4531  AllowExplicit);
4532  }
4533  }
4534  }
4535  }
4536 
4537  // Perform overload resolution. If it fails, return the failed result.
4539  if (OverloadingResult Result
4540  = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
4541  Sequence.SetOverloadFailure(
4543  Result);
4544  return;
4545  }
4546 
4547  FunctionDecl *Function = Best->Function;
4548  Function->setReferenced();
4549  bool HadMultipleCandidates = (CandidateSet.size() > 1);
4550 
4551  if (isa<CXXConstructorDecl>(Function)) {
4552  // Add the user-defined conversion step. Any cv-qualification conversion is
4553  // subsumed by the initialization. Per DR5, the created temporary is of the
4554  // cv-unqualified type of the destination.
4555  Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4556  DestType.getUnqualifiedType(),
4557  HadMultipleCandidates);
4558  return;
4559  }
4560 
4561  // Add the user-defined conversion step that calls the conversion function.
4562  QualType ConvType = Function->getCallResultType();
4563  if (ConvType->getAs<RecordType>()) {
4564  // If we're converting to a class type, there may be an copy of
4565  // the resulting temporary object (possible to create an object of
4566  // a base class type). That copy is not a separate conversion, so
4567  // we just make a note of the actual destination type (possibly a
4568  // base class of the type returned by the conversion function) and
4569  // let the user-defined conversion step handle the conversion.
4570  Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType,
4571  HadMultipleCandidates);
4572  return;
4573  }
4574 
4575  Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
4576  HadMultipleCandidates);
4577 
4578  // If the conversion following the call to the conversion function
4579  // is interesting, add it as a separate step.
4580  if (Best->FinalConversion.First || Best->FinalConversion.Second ||
4581  Best->FinalConversion.Third) {
4583  ICS.setStandard();
4584  ICS.Standard = Best->FinalConversion;
4585  Sequence.AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
4586  }
4587 }
4588 
4589 /// An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>,
4590 /// a function with a pointer return type contains a 'return false;' statement.
4591 /// In C++11, 'false' is not a null pointer, so this breaks the build of any
4592 /// code using that header.
4593 ///
4594 /// Work around this by treating 'return false;' as zero-initializing the result
4595 /// if it's used in a pointer-returning function in a system header.
4597  const InitializedEntity &Entity,
4598  const Expr *Init) {
4599  return S.getLangOpts().CPlusPlus11 &&
4600  Entity.getKind() == InitializedEntity::EK_Result &&
4601  Entity.getType()->isPointerType() &&
4602  isa<CXXBoolLiteralExpr>(Init) &&
4603  !cast<CXXBoolLiteralExpr>(Init)->getValue() &&
4605 }
4606 
4607 /// The non-zero enum values here are indexes into diagnostic alternatives.
4609 
4610 /// Determines whether this expression is an acceptable ICR source.
4612  bool isAddressOf, bool &isWeakAccess) {
4613  // Skip parens.
4614  e = e->IgnoreParens();
4615 
4616  // Skip address-of nodes.
4617  if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
4618  if (op->getOpcode() == UO_AddrOf)
4619  return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
4620  isWeakAccess);
4621 
4622  // Skip certain casts.
4623  } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
4624  switch (ce->getCastKind()) {
4625  case CK_Dependent:
4626  case CK_BitCast:
4627  case CK_LValueBitCast:
4628  case CK_NoOp:
4629  return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
4630 
4632  return IIK_nonscalar;
4633 
4634  case CK_NullToPointer:
4635  return IIK_okay;
4636 
4637  default:
4638  break;
4639  }
4640 
4641  // If we have a declaration reference, it had better be a local variable.
4642  } else if (isa<DeclRefExpr>(e)) {
4643  // set isWeakAccess to true, to mean that there will be an implicit
4644  // load which requires a cleanup.
4646  isWeakAccess = true;
4647 
4648  if (!isAddressOf) return IIK_nonlocal;
4649 
4650  VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
4651  if (!var) return IIK_nonlocal;
4652 
4653  return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
4654 
4655  // If we have a conditional operator, check both sides.
4656  } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
4657  if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
4658  isWeakAccess))
4659  return iik;
4660 
4661  return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
4662 
4663  // These are never scalar.
4664  } else if (isa<ArraySubscriptExpr>(e)) {
4665  return IIK_nonscalar;
4666 
4667  // Otherwise, it needs to be a null pointer constant.
4668  } else {
4670  ? IIK_okay : IIK_nonlocal);
4671  }
4672 
4673  return IIK_nonlocal;
4674 }
4675 
4676 /// Check whether the given expression is a valid operand for an
4677 /// indirect copy/restore.
4679  assert(src->isRValue());
4680  bool isWeakAccess = false;
4681  InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
4682  // If isWeakAccess to true, there will be an implicit
4683  // load which requires a cleanup.
4684  if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
4685  S.ExprNeedsCleanups = true;
4686 
4687  if (iik == IIK_okay) return;
4688 
4689  S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
4690  << ((unsigned) iik - 1) // shift index into diagnostic explanations
4691  << src->getSourceRange();
4692 }
4693 
4694 /// \brief Determine whether we have compatible array types for the
4695 /// purposes of GNU by-copy array initialization.
4696 static bool hasCompatibleArrayTypes(ASTContext &Context, const ArrayType *Dest,
4697  const ArrayType *Source) {
4698  // If the source and destination array types are equivalent, we're
4699  // done.
4700  if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
4701  return true;
4702 
4703  // Make sure that the element types are the same.
4704  if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
4705  return false;
4706 
4707  // The only mismatch we allow is when the destination is an
4708  // incomplete array type and the source is a constant array type.
4709  return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
4710 }
4711 
4713  InitializationSequence &Sequence,
4714  const InitializedEntity &Entity,
4715  Expr *Initializer) {
4716  bool ArrayDecay = false;
4717  QualType ArgType = Initializer->getType();
4718  QualType ArgPointee;
4719  if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
4720  ArrayDecay = true;
4721  ArgPointee = ArgArrayType->getElementType();
4722  ArgType = S.Context.getPointerType(ArgPointee);
4723  }
4724 
4725  // Handle write-back conversion.
4726  QualType ConvertedArgType;
4727  if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
4728  ConvertedArgType))
4729  return false;
4730 
4731  // We should copy unless we're passing to an argument explicitly
4732  // marked 'out'.
4733  bool ShouldCopy = true;
4734  if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4735  ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4736 
4737  // Do we need an lvalue conversion?
4738  if (ArrayDecay || Initializer->isGLValue()) {
4740  ICS.setStandard();
4742 
4743  QualType ResultType;
4744  if (ArrayDecay) {
4746  ResultType = S.Context.getPointerType(ArgPointee);
4747  } else {
4749  ResultType = Initializer->getType().getNonLValueExprType(S.Context);
4750  }
4751 
4752  Sequence.AddConversionSequenceStep(ICS, ResultType);
4753  }
4754 
4755  Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
4756  return true;
4757 }
4758 
4760  InitializationSequence &Sequence,
4761  QualType DestType,
4762  Expr *Initializer) {
4763  if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
4764  !Initializer->isIntegerConstantExpr(S.getASTContext()))
4765  return false;
4766 
4767  Sequence.AddOCLSamplerInitStep(DestType);
4768  return true;
4769 }
4770 
4771 //
4772 // OpenCL 1.2 spec, s6.12.10
4773 //
4774 // The event argument can also be used to associate the
4775 // async_work_group_copy with a previous async copy allowing
4776 // an event to be shared by multiple async copies; otherwise
4777 // event should be zero.
4778 //
4780  InitializationSequence &Sequence,
4781  QualType DestType,
4782  Expr *Initializer) {
4783  if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
4784  !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
4785  (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
4786  return false;
4787 
4788  Sequence.AddOCLZeroEventStep(DestType);
4789  return true;
4790 }
4791 
4793  const InitializedEntity &Entity,
4794  const InitializationKind &Kind,
4795  MultiExprArg Args,
4796  bool TopLevelOfInitList)
4797  : FailedCandidateSet(Kind.getLocation(), OverloadCandidateSet::CSK_Normal) {
4798  InitializeFrom(S, Entity, Kind, Args, TopLevelOfInitList);
4799 }
4800 
4802  const InitializedEntity &Entity,
4803  const InitializationKind &Kind,
4804  MultiExprArg Args,
4805  bool TopLevelOfInitList) {
4806  ASTContext &Context = S.Context;
4807 
4808  // Eliminate non-overload placeholder types in the arguments. We
4809  // need to do this before checking whether types are dependent
4810  // because lowering a pseudo-object expression might well give us
4811  // something of dependent type.
4812  for (unsigned I = 0, E = Args.size(); I != E; ++I)
4813  if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
4814  // FIXME: should we be doing this here?
4815  ExprResult result = S.CheckPlaceholderExpr(Args[I]);
4816  if (result.isInvalid()) {
4818  return;
4819  }
4820  Args[I] = result.get();
4821  }
4822 
4823  // C++0x [dcl.init]p16:
4824  // The semantics of initializers are as follows. The destination type is
4825  // the type of the object or reference being initialized and the source
4826  // type is the type of the initializer expression. The source type is not
4827  // defined when the initializer is a braced-init-list or when it is a
4828  // parenthesized list of expressions.
4829  QualType DestType = Entity.getType();
4830 
4831  if (DestType->isDependentType() ||
4834  return;
4835  }
4836 
4837  // Almost everything is a normal sequence.
4839 
4840  QualType SourceType;
4841  Expr *Initializer = nullptr;
4842  if (Args.size() == 1) {
4843  Initializer = Args[0];
4844  if (S.getLangOpts().ObjC1) {
4845  if (S.CheckObjCBridgeRelatedConversions(Initializer->getLocStart(),
4846  DestType, Initializer->getType(),
4847  Initializer) ||
4848  S.ConversionToObjCStringLiteralCheck(DestType, Initializer))
4849  Args[0] = Initializer;
4850  }
4851  if (!isa<InitListExpr>(Initializer))
4852  SourceType = Initializer->getType();
4853  }
4854 
4855  // - If the initializer is a (non-parenthesized) braced-init-list, the
4856  // object is list-initialized (8.5.4).
4857  if (Kind.getKind() != InitializationKind::IK_Direct) {
4858  if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
4859  TryListInitialization(S, Entity, Kind, InitList, *this);
4860  return;
4861  }
4862  }
4863 
4864  // - If the destination type is a reference type, see 8.5.3.
4865  if (DestType->isReferenceType()) {
4866  // C++0x [dcl.init.ref]p1:
4867  // A variable declared to be a T& or T&&, that is, "reference to type T"
4868  // (8.3.2), shall be initialized by an object, or function, of type T or
4869  // by an object that can be converted into a T.
4870  // (Therefore, multiple arguments are not permitted.)
4871  if (Args.size() != 1)
4873  else
4874  TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
4875  return;
4876  }
4877 
4878  // - If the initializer is (), the object is value-initialized.
4879  if (Kind.getKind() == InitializationKind::IK_Value ||
4880  (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
4881  TryValueInitialization(S, Entity, Kind, *this);
4882  return;
4883  }
4884 
4885  // Handle default initialization.
4886  if (Kind.getKind() == InitializationKind::IK_Default) {
4887  TryDefaultInitialization(S, Entity, Kind, *this);
4888  return;
4889  }
4890 
4891  // - If the destination type is an array of characters, an array of
4892  // char16_t, an array of char32_t, or an array of wchar_t, and the
4893  // initializer is a string literal, see 8.5.2.
4894  // - Otherwise, if the destination type is an array, the program is
4895  // ill-formed.
4896  if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
4897  if (Initializer && isa<VariableArrayType>(DestAT)) {
4899  return;
4900  }
4901 
4902  if (Initializer) {
4903  switch (IsStringInit(Initializer, DestAT, Context)) {
4904  case SIF_None:
4905  TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
4906  return;
4909  return;
4912  return;
4915  return;
4916  case SIF_Other:
4917  break;
4918  }
4919  }
4920 
4921  // Note: as an GNU C extension, we allow initialization of an
4922  // array from a compound literal that creates an array of the same
4923  // type, so long as the initializer has no side effects.
4924  if (!S.getLangOpts().CPlusPlus && Initializer &&
4925  isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
4926  Initializer->getType()->isArrayType()) {
4927  const ArrayType *SourceAT
4928  = Context.getAsArrayType(Initializer->getType());
4929  if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
4931  else if (Initializer->HasSideEffects(S.Context))
4933  else {
4934  AddArrayInitStep(DestType);
4935  }
4936  }
4937  // Note: as a GNU C++ extension, we allow list-initialization of a
4938  // class member of array type from a parenthesized initializer list.
4939  else if (S.getLangOpts().CPlusPlus &&
4940  Entity.getKind() == InitializedEntity::EK_Member &&
4941  Initializer && isa<InitListExpr>(Initializer)) {
4942  TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
4943  *this);
4945  } else if (DestAT->getElementType()->isCharType())
4947  else if (IsWideCharCompatible(DestAT->getElementType(), Context))
4949  else
4951 
4952  return;
4953  }
4954 
4955  // Determine whether we should consider writeback conversions for
4956  // Objective-C ARC.
4957  bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
4958  Entity.isParameterKind();
4959 
4960  // We're at the end of the line for C: it's either a write-back conversion
4961  // or it's a C assignment. There's no need to check anything else.
4962  if (!S.getLangOpts().CPlusPlus) {
4963  // If allowed, check whether this is an Objective-C writeback conversion.
4964  if (allowObjCWritebackConversion &&
4965  tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
4966  return;
4967  }
4968 
4969  if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
4970  return;
4971 
4972  if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
4973  return;
4974 
4975  // Handle initialization in C
4976  AddCAssignmentStep(DestType);
4977  MaybeProduceObjCObject(S, *this, Entity);
4978  return;
4979  }
4980 
4981  assert(S.getLangOpts().CPlusPlus);
4982 
4983  // - If the destination type is a (possibly cv-qualified) class type:
4984  if (DestType->isRecordType()) {
4985  // - If the initialization is direct-initialization, or if it is
4986  // copy-initialization where the cv-unqualified version of the
4987  // source type is the same class as, or a derived class of, the
4988  // class of the destination, constructors are considered. [...]
4989  if (Kind.getKind() == InitializationKind::IK_Direct ||
4990  (Kind.getKind() == InitializationKind::IK_Copy &&
4991  (Context.hasSameUnqualifiedType(SourceType, DestType) ||
4992  S.IsDerivedFrom(SourceType, DestType))))
4993  TryConstructorInitialization(S, Entity, Kind, Args,
4994  DestType, *this);
4995  // - Otherwise (i.e., for the remaining copy-initialization cases),
4996  // user-defined conversion sequences that can convert from the source
4997  // type to the destination type or (when a conversion function is
4998  // used) to a derived class thereof are enumerated as described in
4999  // 13.3.1.4, and the best one is chosen through overload resolution
5000  // (13.3).
5001  else
5002  TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5003  TopLevelOfInitList);
5004  return;
5005  }
5006 
5007  if (Args.size() > 1) {
5009  return;
5010  }
5011  assert(Args.size() == 1 && "Zero-argument case handled above");
5012 
5013  // - Otherwise, if the source type is a (possibly cv-qualified) class
5014  // type, conversion functions are considered.
5015  if (!SourceType.isNull() && SourceType->isRecordType()) {
5016  // For a conversion to _Atomic(T) from either T or a class type derived
5017  // from T, initialize the T object then convert to _Atomic type.
5018  bool NeedAtomicConversion = false;
5019  if (const AtomicType *Atomic = DestType->getAs<AtomicType>()) {
5020  if (Context.hasSameUnqualifiedType(SourceType, Atomic->getValueType()) ||
5021  S.IsDerivedFrom(SourceType, Atomic->getValueType())) {
5022  DestType = Atomic->getValueType();
5023  NeedAtomicConversion = true;
5024  }
5025  }
5026 
5027  TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5028  TopLevelOfInitList);
5029  MaybeProduceObjCObject(S, *this, Entity);
5030  if (!Failed() && NeedAtomicConversion)
5031  AddAtomicConversionStep(Entity.getType());
5032  return;
5033  }
5034 
5035  // - Otherwise, the initial value of the object being initialized is the
5036  // (possibly converted) value of the initializer expression. Standard
5037  // conversions (Clause 4) will be used, if necessary, to convert the
5038  // initializer expression to the cv-unqualified version of the
5039  // destination type; no user-defined conversions are considered.
5040 
5042  = S.TryImplicitConversion(Initializer, DestType,
5043  /*SuppressUserConversions*/true,
5044  /*AllowExplicitConversions*/ false,
5045  /*InOverloadResolution*/ false,
5046  /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
5047  allowObjCWritebackConversion);
5048 
5049  if (ICS.isStandard() &&
5051  // Objective-C ARC writeback conversion.
5052 
5053  // We should copy unless we're passing to an argument explicitly
5054  // marked 'out'.
5055  bool ShouldCopy = true;
5056  if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
5057  ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
5058 
5059  // If there was an lvalue adjustment, add it as a separate conversion.
5060  if (ICS.Standard.First == ICK_Array_To_Pointer ||
5062  ImplicitConversionSequence LvalueICS;
5063  LvalueICS.setStandard();
5064  LvalueICS.Standard.setAsIdentityConversion();
5065  LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0));
5066  LvalueICS.Standard.First = ICS.Standard.First;
5067  AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0));
5068  }
5069 
5070  AddPassByIndirectCopyRestoreStep(DestType, ShouldCopy);
5071  } else if (ICS.isBad()) {
5072  DeclAccessPair dap;
5073  if (isLibstdcxxPointerReturnFalseHack(S, Entity, Initializer)) {
5075  } else if (Initializer->getType() == Context.OverloadTy &&
5076  !S.ResolveAddressOfOverloadedFunction(Initializer, DestType,
5077  false, dap))
5079  else
5081  } else {
5082  AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
5083 
5084  MaybeProduceObjCObject(S, *this, Entity);
5085  }
5086 }
5087 
5089  for (auto &S : Steps)
5090  S.Destroy();
5091 }
5092 
5093 //===----------------------------------------------------------------------===//
5094 // Perform initialization
5095 //===----------------------------------------------------------------------===//
5097 getAssignmentAction(const InitializedEntity &Entity, bool Diagnose = false) {
5098  switch(Entity.getKind()) {
5104  return Sema::AA_Initializing;
5105 
5107  if (Entity.getDecl() &&
5108  isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
5109  return Sema::AA_Sending;
5110 
5111  return Sema::AA_Passing;
5112 
5114  if (Entity.getDecl() &&
5115  isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
5116  return Sema::AA_Sending;
5117 
5118  return !Diagnose ? Sema::AA_Passing : Sema::AA_Passing_CFAudited;
5119 
5121  return Sema::AA_Returning;
5122 
5125  // FIXME: Can we tell apart casting vs. converting?
5126  return Sema::AA_Casting;
5127 
5135  return Sema::AA_Initializing;
5136  }
5137 
5138  llvm_unreachable("Invalid EntityKind!");
5139 }
5140 
5141 /// \brief Whether we should bind a created object as a temporary when
5142 /// initializing the given entity.
5143 static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
5144  switch (Entity.getKind()) {
5158  return false;
5159 
5164  return true;
5165  }
5166 
5167  llvm_unreachable("missed an InitializedEntity kind?");
5168 }
5169 
5170 /// \brief Whether the given entity, when initialized with an object
5171 /// created for that initialization, requires destruction.
5172 static bool shouldDestroyTemporary(const InitializedEntity &Entity) {
5173  switch (Entity.getKind()) {
5182  return false;
5183 
5193  return true;
5194  }
5195 
5196  llvm_unreachable("missed an InitializedEntity kind?");
5197 }
5198 
5199 /// \brief Look for copy and move constructors and constructor templates, for
5200 /// copying an object via direct-initialization (per C++11 [dcl.init]p16).
5202  OverloadCandidateSet &CandidateSet,
5203  CXXRecordDecl *Class,
5204  Expr *CurInitExpr) {
5206  // The container holding the constructors can under certain conditions
5207  // be changed while iterating (e.g. because of deserialization).
5208  // To be safe we copy the lookup results to a new container.
5209  SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
5211  CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
5212  NamedDecl *D = *CI;
5213  CXXConstructorDecl *Constructor = nullptr;
5214 
5215  if ((Constructor = dyn_cast<CXXConstructorDecl>(D))) {
5216  // Handle copy/moveconstructors, only.
5217  if (!Constructor || Constructor->isInvalidDecl() ||
5218  !Constructor->isCopyOrMoveConstructor() ||
5219  !Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
5220  continue;
5221 
5222  DeclAccessPair FoundDecl
5223  = DeclAccessPair::make(Constructor, Constructor->getAccess());
5224  S.AddOverloadCandidate(Constructor, FoundDecl,
5225  CurInitExpr, CandidateSet);
5226  continue;
5227  }
5228 
5229  // Handle constructor templates.
5230  FunctionTemplateDecl *ConstructorTmpl = cast<FunctionTemplateDecl>(D);
5231  if (ConstructorTmpl->isInvalidDecl())
5232  continue;
5233 
5234  Constructor = cast<CXXConstructorDecl>(
5235  ConstructorTmpl->getTemplatedDecl());
5236  if (!Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
5237  continue;
5238 
5239  // FIXME: Do we need to limit this to copy-constructor-like
5240  // candidates?
5241  DeclAccessPair FoundDecl
5242  = DeclAccessPair::make(ConstructorTmpl, ConstructorTmpl->getAccess());
5243  S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, nullptr,
5244  CurInitExpr, CandidateSet, true);
5245  }
5246 }
5247 
5248 /// \brief Get the location at which initialization diagnostics should appear.
5250  Expr *Initializer) {
5251  switch (Entity.getKind()) {
5253  return Entity.getReturnLoc();
5254 
5256  return Entity.getThrowLoc();
5257 
5259  return Entity.getDecl()->getLocation();
5260 
5262  return Entity.getCaptureLoc();
5263 
5277  return Initializer->getLocStart();
5278  }
5279  llvm_unreachable("missed an InitializedEntity kind?");
5280 }
5281 
5282 /// \brief Make a (potentially elidable) temporary copy of the object
5283 /// provided by the given initializer by calling the appropriate copy
5284 /// constructor.
5285 ///
5286 /// \param S The Sema object used for type-checking.
5287 ///
5288 /// \param T The type of the temporary object, which must either be
5289 /// the type of the initializer expression or a superclass thereof.
5290 ///
5291 /// \param Entity The entity being initialized.
5292 ///
5293 /// \param CurInit The initializer expression.
5294 ///
5295 /// \param IsExtraneousCopy Whether this is an "extraneous" copy that
5296 /// is permitted in C++03 (but not C++0x) when binding a reference to
5297 /// an rvalue.
5298 ///
5299 /// \returns An expression that copies the initializer expression into
5300 /// a temporary object, or an error expression if a copy could not be
5301 /// created.
5303  QualType T,
5304  const InitializedEntity &Entity,
5305  ExprResult CurInit,
5306  bool IsExtraneousCopy) {
5307  if (CurInit.isInvalid())
5308  return CurInit;
5309  // Determine which class type we're copying to.
5310  Expr *CurInitExpr = (Expr *)CurInit.get();
5311  CXXRecordDecl *Class = nullptr;
5312  if (const RecordType *Record = T->getAs<RecordType>())
5313  Class = cast<CXXRecordDecl>(Record->getDecl());
5314  if (!Class)
5315  return CurInit;
5316 
5317  // C++0x [class.copy]p32:
5318  // When certain criteria are met, an implementation is allowed to
5319  // omit the copy/move construction of a class object, even if the
5320  // copy/move constructor and/or destructor for the object have
5321  // side effects. [...]
5322  // - when a temporary class object that has not been bound to a
5323  // reference (12.2) would be copied/moved to a class object
5324  // with the same cv-unqualified type, the copy/move operation
5325  // can be omitted by constructing the temporary object
5326  // directly into the target of the omitted copy/move
5327  //
5328  // Note that the other three bullets are handled elsewhere. Copy
5329  // elision for return statements and throw expressions are handled as part
5330  // of constructor initialization, while copy elision for exception handlers
5331  // is handled by the run-time.
5332  bool Elidable = CurInitExpr->isTemporaryObject(S.Context, Class);
5333  SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
5334 
5335  // Make sure that the type we are copying is complete.
5336  if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
5337  return CurInit;
5338 
5339  // Perform overload resolution using the class's copy/move constructors.
5340  // Only consider constructors and constructor templates. Per
5341  // C++0x [dcl.init]p16, second bullet to class types, this initialization
5342  // is direct-initialization.
5344  LookupCopyAndMoveConstructors(S, CandidateSet, Class, CurInitExpr);
5345 
5346  bool HadMultipleCandidates = (CandidateSet.size() > 1);
5347 
5349  switch (CandidateSet.BestViableFunction(S, Loc, Best)) {
5350  case OR_Success:
5351  break;
5352 
5353  case OR_No_Viable_Function:
5354  S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
5355  ? diag::ext_rvalue_to_reference_temp_copy_no_viable
5356  : diag::err_temp_copy_no_viable)
5357  << (int)Entity.getKind() << CurInitExpr->getType()
5358  << CurInitExpr->getSourceRange();
5359  CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5360  if (!IsExtraneousCopy || S.isSFINAEContext())
5361  return ExprError();
5362  return CurInit;
5363 
5364  case OR_Ambiguous:
5365  S.Diag(Loc, diag::err_temp_copy_ambiguous)
5366  << (int)Entity.getKind() << CurInitExpr->getType()
5367  << CurInitExpr->getSourceRange();
5368  CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5369  return ExprError();
5370 
5371  case OR_Deleted:
5372  S.Diag(Loc, diag::err_temp_copy_deleted)
5373  << (int)Entity.getKind() << CurInitExpr->getType()
5374  << CurInitExpr->getSourceRange();
5375  S.NoteDeletedFunction(Best->Function);
5376  return ExprError();
5377  }
5378 
5379  CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
5380  SmallVector<Expr*, 8> ConstructorArgs;
5381  CurInit.get(); // Ownership transferred into MultiExprArg, below.
5382 
5383  S.CheckConstructorAccess(Loc, Constructor, Entity,
5384  Best->FoundDecl.getAccess(), IsExtraneousCopy);
5385 
5386  if (IsExtraneousCopy) {
5387  // If this is a totally extraneous copy for C++03 reference
5388  // binding purposes, just return the original initialization
5389  // expression. We don't generate an (elided) copy operation here
5390  // because doing so would require us to pass down a flag to avoid
5391  // infinite recursion, where each step adds another extraneous,
5392  // elidable copy.
5393 
5394  // Instantiate the default arguments of any extra parameters in
5395  // the selected copy constructor, as if we were going to create a
5396  // proper call to the copy constructor.
5397  for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
5398  ParmVarDecl *Parm = Constructor->getParamDecl(I);
5399  if (S.RequireCompleteType(Loc, Parm->getType(),
5400  diag::err_call_incomplete_argument))
5401  break;
5402 
5403  // Build the default argument expression; we don't actually care
5404  // if this succeeds or not, because this routine will complain
5405  // if there was a problem.
5406  S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
5407  }
5408 
5409  return CurInitExpr;
5410  }
5411 
5412  // Determine the arguments required to actually perform the
5413  // constructor call (we might have derived-to-base conversions, or
5414  // the copy constructor may have default arguments).
5415  if (S.CompleteConstructorCall(Constructor, CurInitExpr, Loc, ConstructorArgs))
5416  return ExprError();
5417 
5418  // Actually perform the constructor call.
5419  CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable,
5420  ConstructorArgs,
5421  HadMultipleCandidates,
5422  /*ListInit*/ false,
5423  /*StdInitListInit*/ false,
5424  /*ZeroInit*/ false,
5426  SourceRange());
5427 
5428  // If we're supposed to bind temporaries, do so.
5429  if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
5430  CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
5431  return CurInit;
5432 }
5433 
5434 /// \brief Check whether elidable copy construction for binding a reference to
5435 /// a temporary would have succeeded if we were building in C++98 mode, for
5436 /// -Wc++98-compat.
5438  const InitializedEntity &Entity,
5439  Expr *CurInitExpr) {
5440  assert(S.getLangOpts().CPlusPlus11);
5441 
5442  const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>();
5443  if (!Record)
5444  return;
5445 
5446  SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr);
5447  if (S.Diags.isIgnored(diag::warn_cxx98_compat_temp_copy, Loc))
5448  return;
5449 
5450  // Find constructors which would have been considered.
5453  S, CandidateSet, cast<CXXRecordDecl>(Record->getDecl()), CurInitExpr);
5454 
5455  // Perform overload resolution.
5457  OverloadingResult OR = CandidateSet.BestViableFunction(S, Loc, Best);
5458 
5459  PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy)
5460  << OR << (int)Entity.getKind() << CurInitExpr->getType()
5461  << CurInitExpr->getSourceRange();
5462 
5463  switch (OR) {
5464  case OR_Success:
5465  S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
5466  Entity, Best->FoundDecl.getAccess(), Diag);
5467  // FIXME: Check default arguments as far as that's possible.
5468  break;
5469 
5470  case OR_No_Viable_Function:
5471  S.Diag(Loc, Diag);
5472  CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5473  break;
5474 
5475  case OR_Ambiguous:
5476  S.Diag(Loc, Diag);
5477  CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5478  break;
5479 
5480  case OR_Deleted:
5481  S.Diag(Loc, Diag);
5482  S.NoteDeletedFunction(Best->Function);
5483  break;
5484  }
5485 }
5486 
5487 void InitializationSequence::PrintInitLocationNote(Sema &S,
5488  const InitializedEntity &Entity) {
5489  if (Entity.isParameterKind() && Entity.getDecl()) {
5490  if (Entity.getDecl()->getLocation().isInvalid())
5491  return;
5492 
5493  if (Entity.getDecl()->getDeclName())
5494  S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
5495  << Entity.getDecl()->getDeclName();
5496  else
5497  S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
5498  }
5499  else if (Entity.getKind() == InitializedEntity::EK_RelatedResult &&
5500  Entity.getMethodDecl())
5501  S.Diag(Entity.getMethodDecl()->getLocation(),
5502  diag::note_method_return_type_change)
5503  << Entity.getMethodDecl()->getDeclName();
5504 }
5505 
5509 }
5510 
5511 /// Returns true if the parameters describe a constructor initialization of
5512 /// an explicit temporary object, e.g. "Point(x, y)".
5513 static bool isExplicitTemporary(const InitializedEntity &Entity,
5514  const InitializationKind &Kind,
5515  unsigned NumArgs) {
5516  switch (Entity.getKind()) {
5520  break;
5521  default:
5522  return false;
5523  }
5524 
5525  switch (Kind.getKind()) {
5527  return true;
5528  // FIXME: Hack to work around cast weirdness.
5531  return NumArgs != 1;
5532  default:
5533  return false;
5534  }
5535 }
5536 
5537 static ExprResult
5539  const InitializedEntity &Entity,
5540  const InitializationKind &Kind,
5541  MultiExprArg Args,
5543  bool &ConstructorInitRequiresZeroInit,
5544  bool IsListInitialization,
5545  bool IsStdInitListInitialization,
5546  SourceLocation LBraceLoc,
5547  SourceLocation RBraceLoc) {
5548  unsigned NumArgs = Args.size();
5549  CXXConstructorDecl *Constructor
5550  = cast<CXXConstructorDecl>(Step.Function.Function);
5551  bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
5552 
5553  // Build a call to the selected constructor.
5554  SmallVector<Expr*, 8> ConstructorArgs;
5555  SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
5556  ? Kind.getEqualLoc()
5557  : Kind.getLocation();
5558 
5559  if (Kind.getKind() == InitializationKind::IK_Default) {
5560  // Force even a trivial, implicit default constructor to be
5561  // semantically checked. We do this explicitly because we don't build
5562  // the definition for completely trivial constructors.
5563  assert(Constructor->getParent() && "No parent class for constructor.");
5564  if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
5565  Constructor->isTrivial() && !Constructor->isUsed(false))
5566  S.DefineImplicitDefaultConstructor(Loc, Constructor);
5567  }
5568 
5569  ExprResult CurInit((Expr *)nullptr);
5570 
5571  // C++ [over.match.copy]p1:
5572  // - When initializing a temporary to be bound to the first parameter
5573  // of a constructor that takes a reference to possibly cv-qualified
5574  // T as its first argument, called with a single argument in the
5575  // context of direct-initialization, explicit conversion functions
5576  // are also considered.
5577  bool AllowExplicitConv = Kind.AllowExplicit() && !Kind.isCopyInit() &&
5578  Args.size() == 1 &&
5579  Constructor->isCopyOrMoveConstructor();
5580 
5581  // Determine the arguments required to actually perform the constructor
5582  // call.
5583  if (S.CompleteConstructorCall(Constructor, Args,
5584  Loc, ConstructorArgs,
5585  AllowExplicitConv,
5586  IsListInitialization))
5587  return ExprError();
5588 
5589 
5590  if (isExplicitTemporary(Entity, Kind, NumArgs)) {
5591  // An explicitly-constructed temporary, e.g., X(1, 2).
5592  S.MarkFunctionReferenced(Loc, Constructor);
5593  if (S.DiagnoseUseOfDecl(Constructor, Loc))
5594  return ExprError();
5595 
5596  TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5597  if (!TSInfo)
5598  TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
5599  SourceRange ParenOrBraceRange =
5601  ? SourceRange(LBraceLoc, RBraceLoc)
5602  : Kind.getParenRange();
5603 
5604  CurInit = new (S.Context) CXXTemporaryObjectExpr(
5605  S.Context, Constructor, TSInfo, ConstructorArgs, ParenOrBraceRange,
5606  HadMultipleCandidates, IsListInitialization,
5607  IsStdInitListInitialization, ConstructorInitRequiresZeroInit);
5608  } else {
5609  CXXConstructExpr::ConstructionKind ConstructKind =
5611 
5612  if (Entity.getKind() == InitializedEntity::EK_Base) {
5613  ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
5616  } else if (Entity.getKind() == InitializedEntity::EK_Delegating) {
5617  ConstructKind = CXXConstructExpr::CK_Delegating;
5618  }
5619 
5620  // Only get the parenthesis or brace range if it is a list initialization or
5621  // direct construction.
5622  SourceRange ParenOrBraceRange;
5623  if (IsListInitialization)
5624  ParenOrBraceRange = SourceRange(LBraceLoc, RBraceLoc);
5625  else if (Kind.getKind() == InitializationKind::IK_Direct)
5626  ParenOrBraceRange = Kind.getParenRange();
5627 
5628  // If the entity allows NRVO, mark the construction as elidable
5629  // unconditionally.
5630  if (Entity.allowsNRVO())
5631  CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5632  Constructor, /*Elidable=*/true,
5633  ConstructorArgs,
5634  HadMultipleCandidates,
5635  IsListInitialization,
5636  IsStdInitListInitialization,
5637  ConstructorInitRequiresZeroInit,
5638  ConstructKind,
5639  ParenOrBraceRange);
5640  else
5641  CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5642  Constructor,
5643  ConstructorArgs,
5644  HadMultipleCandidates,
5645  IsListInitialization,
5646  IsStdInitListInitialization,
5647  ConstructorInitRequiresZeroInit,
5648  ConstructKind,
5649  ParenOrBraceRange);
5650  }
5651  if (CurInit.isInvalid())
5652  return ExprError();
5653 
5654  // Only check access if all of that succeeded.
5655  S.CheckConstructorAccess(Loc, Constructor, Entity,
5656  Step.Function.FoundDecl.getAccess());
5657  if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc))
5658  return ExprError();
5659 
5660  if (shouldBindAsTemporary(Entity))
5661  CurInit = S.MaybeBindToTemporary(CurInit.get());
5662 
5663  return CurInit;
5664 }
5665 
5666 /// Determine whether the specified InitializedEntity definitely has a lifetime
5667 /// longer than the current full-expression. Conservatively returns false if
5668 /// it's unclear.
5669 static bool
5671  const InitializedEntity *Top = &Entity;
5672  while (Top->getParent())
5673  Top = Top->getParent();
5674 
5675  switch (Top->getKind()) {
5683  return true;
5684 
5689  // Could not determine what the full initialization is. Assume it might not
5690  // outlive the full-expression.
5691  return false;
5692 
5699  // The entity being initialized might not outlive the full-expression.
5700  return false;
5701  }
5702 
5703  llvm_unreachable("unknown entity kind");
5704 }
5705 
5706 /// Determine the declaration which an initialized entity ultimately refers to,
5707 /// for the purpose of lifetime-extending a temporary bound to a reference in
5708 /// the initialization of \p Entity.
5710  const InitializedEntity *Entity,
5711  const InitializedEntity *FallbackDecl = nullptr) {
5712  // C++11 [class.temporary]p5:
5713  switch (Entity->getKind()) {
5715  // The temporary [...] persists for the lifetime of the reference
5716  return Entity;
5717 
5719  // For subobjects, we look at the complete object.
5720  if (Entity->getParent())
5722  Entity);
5723 
5724  // except:
5725  // -- A temporary bound to a reference member in a constructor's
5726  // ctor-initializer persists until the constructor exits.
5727  return Entity;
5728 
5731  // -- A temporary bound to a reference parameter in a function call
5732  // persists until the completion of the full-expression containing
5733  // the call.
5735  // -- The lifetime of a temporary bound to the returned value in a
5736  // function return statement is not extended; the temporary is
5737  // destroyed at the end of the full-expression in the return statement.
5739  // -- A temporary bound to a reference in a new-initializer persists
5740  // until the completion of the full-expression containing the
5741  // new-initializer.
5742  return nullptr;
5743 
5747  // We don't yet know the storage duration of the surrounding temporary.
5748  // Assume it's got full-expression duration for now, it will patch up our
5749  // storage duration if that's not correct.
5750  return nullptr;
5751 
5753  // For subobjects, we look at the complete object.
5755  FallbackDecl);
5756 
5759  // We can reach this case for aggregate initialization in a constructor:
5760  // struct A { int &&r; };
5761  // struct B : A { B() : A{0} {} };
5762  // In this case, use the innermost field decl as the context.
5763  return FallbackDecl;
5764 
5770  return nullptr;
5771  }
5772  llvm_unreachable("unknown entity kind");
5773 }
5774 
5775 static void performLifetimeExtension(Expr *Init,
5776  const InitializedEntity *ExtendingEntity);
5777 
5778 /// Update a glvalue expression that is used as the initializer of a reference
5779 /// to note that its lifetime is extended.
5780 /// \return \c true if any temporary had its lifetime extended.
5781 static bool
5783  const InitializedEntity *ExtendingEntity) {
5784  // Walk past any constructs which we can lifetime-extend across.
5785  Expr *Old;
5786  do {
5787  Old = Init;
5788 
5789  if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5790  if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
5791  // This is just redundant braces around an initializer. Step over it.
5792  Init = ILE->getInit(0);
5793  }
5794  }
5795 
5796  // Step over any subobject adjustments; we may have a materialized
5797  // temporary inside them.
5798  SmallVector<const Expr *, 2> CommaLHSs;
5800  Init = const_cast<Expr *>(
5801  Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5802 
5803  // Per current approach for DR1376, look through casts to reference type
5804  // when performing lifetime extension.
5805  if (CastExpr *CE = dyn_cast<CastExpr>(Init))
5806  if (CE->getSubExpr()->isGLValue())
5807  Init = CE->getSubExpr();
5808 
5809  // FIXME: Per DR1213, subscripting on an array temporary produces an xvalue.
5810  // It's unclear if binding a reference to that xvalue extends the array
5811  // temporary.
5812  } while (Init != Old);
5813 
5814  if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) {
5815  // Update the storage duration of the materialized temporary.
5816  // FIXME: Rebuild the expression instead of mutating it.
5817  ME->setExtendingDecl(ExtendingEntity->getDecl(),
5818  ExtendingEntity->allocateManglingNumber());
5819  performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingEntity);
5820  return true;
5821  }
5822 
5823  return false;
5824 }
5825 
5826 /// Update a prvalue expression that is going to be materialized as a
5827 /// lifetime-extended temporary.
5828 static void performLifetimeExtension(Expr *Init,
5829  const InitializedEntity *ExtendingEntity) {
5830  // Dig out the expression which constructs the extended temporary.
5831  SmallVector<const Expr *, 2> CommaLHSs;
5833  Init = const_cast<Expr *>(
5834  Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5835 
5836  if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init))
5837  Init = BTE->getSubExpr();
5838 
5839  if (CXXStdInitializerListExpr *ILE =
5840  dyn_cast<CXXStdInitializerListExpr>(Init)) {
5841  performReferenceExtension(ILE->getSubExpr(), ExtendingEntity);
5842  return;
5843  }
5844 
5845  if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5846  if (ILE->getType()->isArrayType()) {
5847  for (unsigned I = 0, N = ILE->getNumInits(); I != N; ++I)
5848  performLifetimeExtension(ILE->getInit(I), ExtendingEntity);
5849  return;
5850  }
5851 
5852  if (CXXRecordDecl *RD = ILE->getType()->getAsCXXRecordDecl()) {
5853  assert(RD->isAggregate() && "aggregate init on non-aggregate");
5854 
5855  // If we lifetime-extend a braced initializer which is initializing an
5856  // aggregate, and that aggregate contains reference members which are
5857  // bound to temporaries, those temporaries are also lifetime-extended.
5858  if (RD->isUnion() && ILE->getInitializedFieldInUnion() &&
5859  ILE->getInitializedFieldInUnion()->getType()->isReferenceType())
5860  performReferenceExtension(ILE->getInit(0), ExtendingEntity);
5861  else {
5862  unsigned Index = 0;
5863  for (const auto *I : RD->fields()) {
5864  if (Index >= ILE->getNumInits())
5865  break;
5866  if (I->isUnnamedBitfield())
5867  continue;
5868  Expr *SubInit = ILE->getInit(Index);
5869  if (I->getType()->isReferenceType())
5870  performReferenceExtension(SubInit, ExtendingEntity);
5871  else if (isa<InitListExpr>(SubInit) ||
5872  isa<CXXStdInitializerListExpr>(SubInit))
5873  // This may be either aggregate-initialization of a member or
5874  // initialization of a std::initializer_list object. Either way,
5875  // we should recursively lifetime-extend that initializer.
5876  performLifetimeExtension(SubInit, ExtendingEntity);
5877  ++Index;
5878  }
5879  }
5880  }
5881  }
5882 }
5883 
5884 static void warnOnLifetimeExtension(Sema &S, const InitializedEntity &Entity,
5885  const Expr *Init, bool IsInitializerList,
5886  const ValueDecl *ExtendingDecl) {
5887  // Warn if a field lifetime-extends a temporary.
5888  if (isa<FieldDecl>(ExtendingDecl)) {
5889  if (IsInitializerList) {
5890  S.Diag(Init->getExprLoc(), diag::warn_dangling_std_initializer_list)
5891  << /*at end of constructor*/true;
5892  return;
5893  }
5894 
5895  bool IsSubobjectMember = false;
5896  for (const InitializedEntity *Ent = Entity.getParent(); Ent;
5897  Ent = Ent->getParent()) {
5898  if (Ent->getKind() != InitializedEntity::EK_Base) {
5899  IsSubobjectMember = true;
5900  break;
5901  }
5902  }
5903  S.Diag(Init->getExprLoc(),
5904  diag::warn_bind_ref_member_to_temporary)
5905  << ExtendingDecl << Init->getSourceRange()
5906  << IsSubobjectMember << IsInitializerList;
5907  if (IsSubobjectMember)
5908  S.Diag(ExtendingDecl->getLocation(),
5909  diag::note_ref_subobject_of_member_declared_here);
5910  else
5911  S.Diag(ExtendingDecl->getLocation(),
5912  diag::note_ref_or_ptr_member_declared_here)
5913  << /*is pointer*/false;
5914  }
5915 }
5916 
5917 static void DiagnoseNarrowingInInitList(Sema &S,
5918  const ImplicitConversionSequence &ICS,
5919  QualType PreNarrowingType,
5920  QualType EntityType,
5921  const Expr *PostInit);
5922 
5923 /// Provide warnings when std::move is used on construction.
5924 static void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr,
5925  bool IsReturnStmt) {
5926  if (!InitExpr)
5927  return;
5928 
5929  if (!S.ActiveTemplateInstantiations.empty())
5930  return;
5931 
5932  QualType DestType = InitExpr->getType();
5933  if (!DestType->isRecordType())
5934  return;
5935 
5936  unsigned DiagID = 0;
5937  if (IsReturnStmt) {
5938  const CXXConstructExpr *CCE =
5939  dyn_cast<CXXConstructExpr>(InitExpr->IgnoreParens());
5940  if (!CCE || CCE->getNumArgs() != 1)
5941  return;
5942 
5943  if (!CCE->getConstructor()->isCopyOrMoveConstructor())
5944  return;
5945 
5946  InitExpr = CCE->getArg(0)->IgnoreImpCasts();
5947  }
5948 
5949  // Find the std::move call and get the argument.
5950  const CallExpr *CE = dyn_cast<CallExpr>(InitExpr->IgnoreParens());
5951  if (!CE || CE->getNumArgs() != 1)
5952  return;
5953 
5954  const FunctionDecl *MoveFunction = CE->getDirectCallee();
5955  if (!MoveFunction || !MoveFunction->isInStdNamespace() ||
5956  !MoveFunction->getIdentifier() ||
5957  !MoveFunction->getIdentifier()->isStr("move"))
5958  return;
5959 
5960  const Expr *Arg = CE->getArg(0)->IgnoreImplicit();
5961 
5962  if (IsReturnStmt) {
5963  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts());
5964  if (!DRE || DRE->refersToEnclosingVariableOrCapture())
5965  return;
5966 
5967  const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl());
5968  if (!VD || !VD->hasLocalStorage())
5969  return;
5970 
5971  QualType SourceType = VD->getType();
5972  if (!SourceType->isRecordType())
5973  return;
5974 
5975  if (!S.Context.hasSameUnqualifiedType(DestType, SourceType)) {
5976  return;
5977  }
5978 
5979  // If we're returning a function parameter, copy elision
5980  // is not possible.
5981  if (isa<ParmVarDecl>(VD))
5982  DiagID = diag::warn_redundant_move_on_return;
5983  else
5984  DiagID = diag::warn_pessimizing_move_on_return;
5985  } else {
5986  DiagID = diag::warn_pessimizing_move_on_initialization;
5987  const Expr *ArgStripped = Arg->IgnoreImplicit()->IgnoreParens();
5988  if (!ArgStripped->isRValue() || !ArgStripped->getType()->isRecordType())
5989  return;
5990  }
5991 
5992  S.Diag(CE->getLocStart(), DiagID);
5993 
5994  // Get all the locations for a fix-it. Don't emit the fix-it if any location
5995  // is within a macro.
5996  SourceLocation CallBegin = CE->getCallee()->getLocStart();
5997  if (CallBegin.isMacroID())
5998  return;
5999  SourceLocation RParen = CE->getRParenLoc();
6000  if (RParen.isMacroID())
6001  return;
6002  SourceLocation LParen;
6003  SourceLocation ArgLoc = Arg->getLocStart();
6004 
6005  // Special testing for the argument location. Since the fix-it needs the
6006  // location right before the argument, the argument location can be in a
6007  // macro only if it is at the beginning of the macro.
6008  while (ArgLoc.isMacroID() &&
6010  ArgLoc = S.getSourceManager().getImmediateExpansionRange(ArgLoc).first;
6011  }
6012 
6013  if (LParen.isMacroID())
6014  return;
6015 
6016  LParen = ArgLoc.getLocWithOffset(-1);
6017 
6018  S.Diag(CE->getLocStart(), diag::note_remove_move)
6019  << FixItHint::CreateRemoval(SourceRange(CallBegin, LParen))
6020  << FixItHint::CreateRemoval(SourceRange(RParen, RParen));
6021 }
6022 
6023 ExprResult
6025  const InitializedEntity &Entity,
6026  const InitializationKind &Kind,
6027  MultiExprArg Args,
6028  QualType *ResultType) {
6029  if (Failed()) {
6030  Diagnose(S, Entity, Kind, Args);
6031  return ExprError();
6032  }
6033  if (!ZeroInitializationFixit.empty()) {
6034  unsigned DiagID = diag::err_default_init_const;
6035  if (Decl *D = Entity.getDecl())
6036  if (S.getLangOpts().MSVCCompat && D->hasAttr<SelectAnyAttr>())
6037  DiagID = diag::ext_default_init_const;
6038 
6039  // The initialization would have succeeded with this fixit. Since the fixit
6040  // is on the error, we need to build a valid AST in this case, so this isn't
6041  // handled in the Failed() branch above.
6042  QualType DestType = Entity.getType();
6043  S.Diag(Kind.getLocation(), DiagID)
6044  << DestType << (bool)DestType->getAs<RecordType>()
6045  << FixItHint::CreateInsertion(ZeroInitializationFixitLoc,
6046  ZeroInitializationFixit);
6047  }
6048 
6049  if (getKind() == DependentSequence) {
6050  // If the declaration is a non-dependent, incomplete array type
6051  // that has an initializer, then its type will be completed once
6052  // the initializer is instantiated.
6053  if (ResultType && !Entity.getType()->isDependentType() &&
6054  Args.size() == 1) {
6055  QualType DeclType = Entity.getType();
6056  if (const IncompleteArrayType *ArrayT
6057  = S.Context.getAsIncompleteArrayType(DeclType)) {
6058  // FIXME: We don't currently have the ability to accurately
6059  // compute the length of an initializer list without
6060  // performing full type-checking of the initializer list
6061  // (since we have to determine where braces are implicitly
6062  // introduced and such). So, we fall back to making the array
6063  // type a dependently-sized array type with no specified
6064  // bound.
6065  if (isa<InitListExpr>((Expr *)Args[0])) {
6066  SourceRange Brackets;
6067 
6068  // Scavange the location of the brackets from the entity, if we can.
6069  if (DeclaratorDecl *DD = Entity.getDecl()) {
6070  if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
6071  TypeLoc TL = TInfo->getTypeLoc();
6072  if (IncompleteArrayTypeLoc ArrayLoc =
6074  Brackets = ArrayLoc.getBracketsRange();
6075  }
6076  }
6077 
6078  *ResultType
6079  = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
6080  /*NumElts=*/nullptr,
6081  ArrayT->getSizeModifier(),
6082  ArrayT->getIndexTypeCVRQualifiers(),
6083  Brackets);
6084  }
6085 
6086  }
6087  }
6088  if (Kind.getKind() == InitializationKind::IK_Direct &&
6089  !Kind.isExplicitCast()) {
6090  // Rebuild the ParenListExpr.
6091  SourceRange ParenRange = Kind.getParenRange();
6092  return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(),
6093  Args);
6094  }
6095  assert(Kind.getKind() == InitializationKind::IK_Copy ||
6096  Kind.isExplicitCast() ||
6098  return ExprResult(Args[0]);
6099  }
6100 
6101  // No steps means no initialization.
6102  if (Steps.empty())
6103  return ExprResult((Expr *)nullptr);
6104 
6105  if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
6106  Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
6107  !Entity.isParameterKind()) {
6108  // Produce a C++98 compatibility warning if we are initializing a reference
6109  // from an initializer list. For parameters, we produce a better warning
6110  // elsewhere.
6111  Expr *Init = Args[0];
6112  S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
6113  << Init->getSourceRange();
6114  }
6115 
6116  // Diagnose cases where we initialize a pointer to an array temporary, and the
6117  // pointer obviously outlives the temporary.
6118  if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
6119  Entity.getType()->isPointerType() &&
6121  Expr *Init = Args[0];
6123  if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
6124  S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
6125  << Init->getSourceRange();
6126  }
6127 
6128  QualType DestType = Entity.getType().getNonReferenceType();
6129  // FIXME: Ugly hack around the fact that Entity.getType() is not
6130  // the same as Entity.getDecl()->getType() in cases involving type merging,
6131  // and we want latter when it makes sense.
6132  if (ResultType)
6133  *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
6134  Entity.getType();
6135 
6136  ExprResult CurInit((Expr *)nullptr);
6137 
6138  // For initialization steps that start with a single initializer,
6139  // grab the only argument out the Args and place it into the "current"
6140  // initializer.
6141  switch (Steps.front().Kind) {
6146  case SK_BindReference:
6149  case SK_UserConversion:
6153  case SK_AtomicConversion:
6154  case SK_LValueToRValue:
6155  case SK_ConversionSequence:
6157  case SK_ListInitialization:
6158  case SK_UnwrapInitList:
6159  case SK_RewrapInitList:
6160  case SK_CAssignment:
6161  case SK_StringInit:
6163  case SK_ArrayInit:
6167  case SK_ProduceObjCObject:
6168  case SK_StdInitializerList:
6169  case SK_OCLSamplerInit:
6170  case SK_OCLZeroEvent: {
6171  assert(Args.size() == 1);
6172  CurInit = Args[0];
6173  if (!CurInit.get()) return ExprError();
6174  break;
6175  }
6176 
6180  case SK_ZeroInitialization:
6181  break;
6182  }
6183 
6184  // Walk through the computed steps for the initialization sequence,
6185  // performing the specified conversions along the way.
6186  bool ConstructorInitRequiresZeroInit = false;
6187  for (step_iterator Step = step_begin(), StepEnd = step_end();
6188  Step != StepEnd; ++Step) {
6189  if (CurInit.isInvalid())
6190  return ExprError();
6191 
6192  QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
6193 
6194  switch (Step->Kind) {
6196  // Overload resolution determined which function invoke; update the
6197  // initializer to reflect that choice.
6200  return ExprError();
6201  CurInit = S.FixOverloadedFunctionReference(CurInit,
6204  break;
6205 
6209  // We have a derived-to-base cast that produces either an rvalue or an
6210  // lvalue. Perform that cast.
6211 
6212  CXXCastPath BasePath;
6213 
6214  // Casts to inaccessible base classes are allowed with C-style casts.
6215  bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
6216  if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
6217  CurInit.get()->getLocStart(),
6218  CurInit.get()->getSourceRange(),
6219  &BasePath, IgnoreBaseAccess))
6220  return ExprError();
6221 
6222  ExprValueKind VK =
6224  VK_LValue :
6226  VK_XValue :
6227  VK_RValue);
6228  CurInit =
6230  CurInit.get(), &BasePath, VK);
6231  break;
6232  }
6233 
6234  case SK_BindReference:
6235  // References cannot bind to bit-fields (C++ [dcl.init.ref]p5).
6236  if (CurInit.get()->refersToBitField()) {
6237  // We don't necessarily have an unambiguous source bit-field.
6238  FieldDecl *BitField = CurInit.get()->getSourceBitField();
6239  S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
6240  << Entity.getType().isVolatileQualified()
6241  << (BitField ? BitField->getDeclName() : DeclarationName())
6242  << (BitField != nullptr)
6243  << CurInit.get()->getSourceRange();
6244  if (BitField)
6245  S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
6246 
6247  return ExprError();
6248  }
6249 
6250  if (CurInit.get()->refersToVectorElement()) {
6251  // References cannot bind to vector elements.
6252  S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
6253  << Entity.getType().isVolatileQualified()
6254  << CurInit.get()->getSourceRange();
6255  PrintInitLocationNote(S, Entity);
6256  return ExprError();
6257  }
6258 
6259  // Reference binding does not have any corresponding ASTs.
6260 
6261  // Check exception specifications
6262  if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
6263  return ExprError();
6264 
6265  // Even though we didn't materialize a temporary, the binding may still
6266  // extend the lifetime of a temporary. This happens if we bind a reference
6267  // to the result of a cast to reference type.
6268  if (const InitializedEntity *ExtendingEntity =
6270  if (performReferenceExtension(CurInit.get(), ExtendingEntity))
6271  warnOnLifetimeExtension(S, Entity, CurInit.get(),
6272  /*IsInitializerList=*/false,
6273  ExtendingEntity->getDecl());
6274 
6275  break;
6276 
6278  // Make sure the "temporary" is actually an rvalue.
6279  assert(CurInit.get()->isRValue() && "not a temporary");
6280 
6281  // Check exception specifications
6282  if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
6283  return ExprError();
6284 
6285  // Materialize the temporary into memory.
6287  Entity.getType().getNonReferenceType(), CurInit.get(),
6288  Entity.getType()->isLValueReferenceType());
6289 
6290  // Maybe lifetime-extend the temporary's subobjects to match the
6291  // entity's lifetime.
6292  if (const InitializedEntity *ExtendingEntity =
6294  if (performReferenceExtension(MTE, ExtendingEntity))
6295  warnOnLifetimeExtension(S, Entity, CurInit.get(), /*IsInitializerList=*/false,
6296  ExtendingEntity->getDecl());
6297 
6298  // If we're binding to an Objective-C object that has lifetime, we
6299  // need cleanups. Likewise if we're extending this temporary to automatic
6300  // storage duration -- we need to register its cleanup during the
6301  // full-expression's cleanups.
6302  if ((S.getLangOpts().ObjCAutoRefCount &&
6303  MTE->getType()->isObjCLifetimeType()) ||
6304  (MTE->getStorageDuration() == SD_Automatic &&
6305  MTE->getType().isDestructedType()))
6306  S.ExprNeedsCleanups = true;
6307 
6308  CurInit = MTE;
6309  break;
6310  }
6311 
6313  CurInit = CopyObject(S, Step->Type, Entity, CurInit,
6314  /*IsExtraneousCopy=*/true);
6315  break;
6316 
6317  case SK_UserConversion: {
6318  // We have a user-defined conversion that invokes either a constructor
6319  // or a conversion function.
6321  bool IsCopy = false;
6324  bool HadMultipleCandidates = Step->Function.HadMultipleCandidates;
6325  bool CreatedObject = false;
6326  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
6327  // Build a call to the selected constructor.
6328  SmallVector<Expr*, 8> ConstructorArgs;
6329  SourceLocation Loc = CurInit.get()->getLocStart();
6330  CurInit.get(); // Ownership transferred into MultiExprArg, below.
6331 
6332  // Determine the arguments required to actually perform the constructor
6333  // call.
6334  Expr *Arg = CurInit.get();
6335  if (S.CompleteConstructorCall(Constructor,
6336  MultiExprArg(&Arg, 1),
6337  Loc, ConstructorArgs))
6338  return ExprError();
6339 
6340  // Build an expression that constructs a temporary.
6341  CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor,
6342  ConstructorArgs,
6343  HadMultipleCandidates,
6344  /*ListInit*/ false,
6345  /*StdInitListInit*/ false,
6346  /*ZeroInit*/ false,
6348  SourceRange());
6349  if (CurInit.isInvalid())
6350  return ExprError();
6351 
6352  S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity,
6353  FoundFn.getAccess());
6354  if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
6355  return ExprError();
6356 
6357  CastKind = CK_ConstructorConversion;
6358  QualType Class = S.Context.getTypeDeclType(Constructor->getParent());
6359  if (S.Context.hasSameUnqualifiedType(SourceType, Class) ||
6360  S.IsDerivedFrom(SourceType, Class))
6361  IsCopy = true;
6362 
6363  CreatedObject = true;
6364  } else {
6365  // Build a call to the conversion function.
6366  CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
6367  S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), nullptr,
6368  FoundFn);
6369  if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
6370  return ExprError();
6371 
6372  // FIXME: Should we move this initialization into a separate
6373  // derived-to-base conversion? I believe the answer is "no", because
6374  // we don't want to turn off access control here for c-style casts.
6375  ExprResult CurInitExprRes =
6377  /*Qualifier=*/nullptr,
6378  FoundFn, Conversion);
6379  if(CurInitExprRes.isInvalid())
6380  return ExprError();
6381  CurInit = CurInitExprRes;
6382 
6383  // Build the actual call to the conversion function.
6384  CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion,
6385  HadMultipleCandidates);
6386  if (CurInit.isInvalid() || !CurInit.get())
6387  return ExprError();
6388 
6389  CastKind = CK_UserDefinedConversion;
6390 
6391  CreatedObject = Conversion->getReturnType()->isRecordType();
6392  }
6393 
6394  bool RequiresCopy = !IsCopy && !isReferenceBinding(Steps.back());
6395  bool MaybeBindToTemp = RequiresCopy || shouldBindAsTemporary(Entity);
6396 
6397  if (!MaybeBindToTemp && CreatedObject && shouldDestroyTemporary(Entity)) {
6398  QualType T = CurInit.get()->getType();
6399  if (const RecordType *Record = T->getAs<RecordType>()) {
6400  CXXDestructorDecl *Destructor
6401  = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl()));
6402  S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor,
6403  S.PDiag(diag::err_access_dtor_temp) << T);
6404  S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor);
6405  if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart()))
6406  return ExprError();
6407  }
6408  }
6409 
6410  CurInit = ImplicitCastExpr::Create(S.Context, CurInit.get()->getType(),
6411  CastKind, CurInit.get(), nullptr,
6412  CurInit.get()->getValueKind());
6413  if (MaybeBindToTemp)
6414  CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
6415  if (RequiresCopy)
6416  CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity,
6417  CurInit, /*IsExtraneousCopy=*/false);
6418  break;
6419  }
6420 
6424  // Perform a qualification conversion; these can never go wrong.
6425  ExprValueKind VK =
6427  VK_LValue :
6429  VK_XValue :
6430  VK_RValue);
6431  CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type, CK_NoOp, VK);
6432  break;
6433  }
6434 
6435  case SK_AtomicConversion: {
6436  assert(CurInit.get()->isRValue() && "cannot convert glvalue to atomic");
6437  CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6439  break;
6440  }
6441 
6442  case SK_LValueToRValue: {
6443  assert(CurInit.get()->isGLValue() && "cannot load from a prvalue");
6444  CurInit = ImplicitCastExpr::Create(S.Context, Step->Type,
6445  CK_LValueToRValue, CurInit.get(),
6446  /*BasePath=*/nullptr, VK_RValue);
6447  break;
6448  }
6449 
6450  case SK_ConversionSequence:
6457  ExprResult CurInitExprRes =
6458  S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,
6459  getAssignmentAction(Entity), CCK);
6460  if (CurInitExprRes.isInvalid())
6461  return ExprError();
6462  CurInit = CurInitExprRes;
6463 
6465  S.getLangOpts().CPlusPlus && !CurInit.get()->isValueDependent())
6466  DiagnoseNarrowingInInitList(S, *Step->ICS, SourceType, Entity.getType(),
6467  CurInit.get());
6468  break;
6469  }
6470 
6471  case SK_ListInitialization: {
6472  InitListExpr *InitList = cast<InitListExpr>(CurInit.get());
6473  // If we're not initializing the top-level entity, we need to create an
6474  // InitializeTemporary entity for our target type.
6475  QualType Ty = Step->Type;
6476  bool IsTemporary = !S.Context.hasSameType(Entity.getType(), Ty);
6478  InitializedEntity InitEntity = IsTemporary ? TempEntity : Entity;
6479  InitListChecker PerformInitList(S, InitEntity,
6480  InitList, Ty, /*VerifyOnly=*/false);
6481  if (PerformInitList.HadError())
6482  return ExprError();
6483 
6484  // Hack: We must update *ResultType if available in order to set the
6485  // bounds of arrays, e.g. in 'int ar[] = {1, 2, 3};'.
6486  // Worst case: 'const int (&arref)[] = {1, 2, 3};'.
6487  if (ResultType &&
6488  ResultType->getNonReferenceType()->isIncompleteArrayType()) {
6489  if ((*ResultType)->isRValueReferenceType())
6490  Ty = S.Context.getRValueReferenceType(Ty);
6491  else if ((*ResultType)->isLValueReferenceType())
6492  Ty = S.Context.getLValueReferenceType(Ty,
6493  (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue());
6494  *ResultType = Ty;
6495  }
6496 
6497  InitListExpr *StructuredInitList =
6498  PerformInitList.getFullyStructuredList();
6499  CurInit.get();
6500  CurInit = shouldBindAsTemporary(InitEntity)
6501  ? S.MaybeBindToTemporary(StructuredInitList)
6502  : StructuredInitList;
6503  break;
6504  }
6505 
6507  // When an initializer list is passed for a parameter of type "reference
6508  // to object", we don't get an EK_Temporary entity, but instead an
6509  // EK_Parameter entity with reference type.
6510  // FIXME: This is a hack. What we really should do is create a user
6511  // conversion step for this case, but this makes it considerably more
6512  // complicated. For now, this will do.
6514  Entity.getType().getNonReferenceType());
6515  bool UseTemporary = Entity.getType()->isReferenceType();
6516  assert(Args.size() == 1 && "expected a single argument for list init");
6517  InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6518  S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
6519  << InitList->getSourceRange();
6520  MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
6521  CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
6522  Entity,
6523  Kind, Arg, *Step,
6524  ConstructorInitRequiresZeroInit,
6525  /*IsListInitialization*/true,
6526  /*IsStdInitListInit*/false,
6527  InitList->getLBraceLoc(),
6528  InitList->getRBraceLoc());
6529  break;
6530  }
6531 
6532  case SK_UnwrapInitList:
6533  CurInit = cast<InitListExpr>(CurInit.get())->getInit(0);
6534  break;
6535 
6536  case SK_RewrapInitList: {
6537  Expr *E = CurInit.get();
6538  InitListExpr *Syntactic = Step->WrappingSyntacticList;
6539  InitListExpr *ILE = new (S.Context) InitListExpr(S.Context,
6540  Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc());
6541  ILE->setSyntacticForm(Syntactic);
6542  ILE->setType(E->getType());
6543  ILE->setValueKind(E->getValueKind());
6544  CurInit = ILE;
6545  break;
6546  }
6547 
6550  // When an initializer list is passed for a parameter of type "reference
6551  // to object", we don't get an EK_Temporary entity, but instead an
6552  // EK_Parameter entity with reference type.
6553  // FIXME: This is a hack. What we really should do is create a user
6554  // conversion step for this case, but this makes it considerably more
6555  // complicated. For now, this will do.
6557  Entity.getType().getNonReferenceType());
6558  bool UseTemporary = Entity.getType()->isReferenceType();
6559  bool IsStdInitListInit =
6562  S, UseTemporary ? TempEntity : Entity, Kind, Args, *Step,
6563  ConstructorInitRequiresZeroInit,
6564  /*IsListInitialization*/IsStdInitListInit,
6565  /*IsStdInitListInitialization*/IsStdInitListInit,
6566  /*LBraceLoc*/SourceLocation(),
6567  /*RBraceLoc*/SourceLocation());
6568  break;
6569  }
6570 
6571  case SK_ZeroInitialization: {
6572  step_iterator NextStep = Step;
6573  ++NextStep;
6574  if (NextStep != StepEnd &&
6575  (NextStep->Kind == SK_ConstructorInitialization ||
6576  NextStep->Kind == SK_ConstructorInitializationFromList)) {
6577  // The need for zero-initialization is recorded directly into
6578  // the call to the object's constructor within the next step.
6579  ConstructorInitRequiresZeroInit = true;
6580  } else if (Kind.getKind() == InitializationKind::IK_Value &&
6581  S.getLangOpts().CPlusPlus &&
6582  !Kind.isImplicitValueInit()) {
6583  TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
6584  if (!TSInfo)
6586  Kind.getRange().getBegin());
6587 
6588  CurInit = new (S.Context) CXXScalarValueInitExpr(
6589  TSInfo->getType().getNonLValueExprType(S.Context), TSInfo,
6590  Kind.getRange().getEnd());
6591  } else {
6592  CurInit = new (S.Context) ImplicitValueInitExpr(Step->Type);
6593  }
6594  break;
6595  }
6596 
6597  case SK_CAssignment: {
6598  QualType SourceType = CurInit.get()->getType();
6599  ExprResult Result = CurInit;
6600  Sema::AssignConvertType ConvTy =
6601  S.CheckSingleAssignmentConstraints(Step->Type, Result, true,
6603  if (Result.isInvalid())
6604  return ExprError();
6605  CurInit = Result;
6606 
6607  // If this is a call, allow conversion to a transparent union.
6608  ExprResult CurInitExprRes = CurInit;
6609  if (ConvTy != Sema::Compatible &&
6610  Entity.isParameterKind() &&
6612  == Sema::Compatible)
6613  ConvTy = Sema::Compatible;
6614  if (CurInitExprRes.isInvalid())
6615  return ExprError();
6616  CurInit = CurInitExprRes;
6617 
6618  bool Complained;
6619  if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
6620  Step->Type, SourceType,
6621  CurInit.get(),
6622  getAssignmentAction(Entity, true),
6623  &Complained)) {
6624  PrintInitLocationNote(S, Entity);
6625  return ExprError();
6626  } else if (Complained)
6627  PrintInitLocationNote(S, Entity);
6628  break;
6629  }
6630 
6631  case SK_StringInit: {
6632  QualType Ty = Step->Type;
6633  CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty,
6634  S.Context.getAsArrayType(Ty), S);
6635  break;
6636  }
6637 
6639  CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6641  CurInit.get()->getValueKind());
6642  break;
6643 
6644  case SK_ArrayInit:
6645  // Okay: we checked everything before creating this step. Note that
6646  // this is a GNU extension.
6647  S.Diag(Kind.getLocation(), diag::ext_array_init_copy)
6648  << Step->Type << CurInit.get()->getType()
6649  << CurInit.get()->getSourceRange();
6650 
6651  // If the destination type is an incomplete array type, update the
6652  // type accordingly.
6653  if (ResultType) {
6654  if (const IncompleteArrayType *IncompleteDest
6656  if (const ConstantArrayType *ConstantSource
6657  = S.Context.getAsConstantArrayType(CurInit.get()->getType())) {
6658  *ResultType = S.Context.getConstantArrayType(
6659  IncompleteDest->getElementType(),
6660  ConstantSource->getSize(),
6661  ArrayType::Normal, 0);
6662  }
6663  }
6664  }
6665  break;
6666 
6668  // Okay: we checked everything before creating this step. Note that
6669  // this is a GNU extension.
6670  S.Diag(Kind.getLocation(), diag::ext_array_init_parens)
6671  << CurInit.get()->getSourceRange();
6672  break;
6673 
6676  checkIndirectCopyRestoreSource(S, CurInit.get());
6677  CurInit = new (S.Context) ObjCIndirectCopyRestoreExpr(
6678  CurInit.get(), Step->Type,
6680  break;
6681 
6682  case SK_ProduceObjCObject:
6683  CurInit =
6685  CurInit.get(), nullptr, VK_RValue);
6686  break;
6687 
6688  case SK_StdInitializerList: {
6689  S.Diag(CurInit.get()->getExprLoc(),
6690  diag::warn_cxx98_compat_initializer_list_init)
6691  << CurInit.get()->getSourceRange();
6692 
6693  // Materialize the temporary into memory.
6694  MaterializeTemporaryExpr *MTE = new (S.Context)
6695  MaterializeTemporaryExpr(CurInit.get()->getType(), CurInit.get(),
6696  /*BoundToLvalueReference=*/false);
6697 
6698  // Maybe lifetime-extend the array temporary's subobjects to match the
6699  // entity's lifetime.
6700  if (const InitializedEntity *ExtendingEntity =
6702  if (performReferenceExtension(MTE, ExtendingEntity))
6703  warnOnLifetimeExtension(S, Entity, CurInit.get(),
6704  /*IsInitializerList=*/true,
6705  ExtendingEntity->getDecl());
6706 
6707  // Wrap it in a construction of a std::initializer_list<T>.
6708  CurInit = new (S.Context) CXXStdInitializerListExpr(Step->Type, MTE);
6709 
6710  // Bind the result, in case the library has given initializer_list a
6711  // non-trivial destructor.
6712  if (shouldBindAsTemporary(Entity))
6713  CurInit = S.MaybeBindToTemporary(CurInit.get());
6714  break;
6715  }
6716 
6717  case SK_OCLSamplerInit: {
6718  assert(Step->Type->isSamplerT() &&
6719  "Sampler initialization on non-sampler type.");
6720 
6721  QualType SourceType = CurInit.get()->getType();
6722 
6723  if (Entity.isParameterKind()) {
6724  if (!SourceType->isSamplerT())
6725  S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
6726  << SourceType;
6727  } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
6728  llvm_unreachable("Invalid EntityKind!");
6729  }
6730 
6731  break;
6732  }
6733  case SK_OCLZeroEvent: {
6734  assert(Step->Type->isEventT() &&
6735  "Event initialization on non-event type.");
6736 
6737  CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6739  CurInit.get()->getValueKind());
6740  break;
6741  }
6742  }
6743  }
6744 
6745  // Diagnose non-fatal problems with the completed initialization.
6746  if (Entity.getKind() == InitializedEntity::EK_Member &&
6747  cast<FieldDecl>(Entity.getDecl())->isBitField())
6748  S.CheckBitFieldInitialization(Kind.getLocation(),
6749  cast<FieldDecl>(Entity.getDecl()),
6750  CurInit.get());
6751 
6752  // Check for std::move on construction.
6753  if (const Expr *E = CurInit.get()) {
6756  }
6757 
6758  return CurInit;
6759 }
6760 
6761 /// Somewhere within T there is an uninitialized reference subobject.
6762 /// Dig it out and diagnose it.
6764  QualType T) {
6765  if (T->isReferenceType()) {
6766  S.Diag(Loc, diag::err_reference_without_init)
6767  << T.getNonReferenceType();
6768  return true;
6769  }
6770 
6772  if (!RD || !RD->hasUninitializedReferenceMember())
6773  return false;
6774 
6775  for (const auto *FI : RD->fields()) {
6776  if (FI->isUnnamedBitfield())
6777  continue;
6778 
6779  if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {
6780  S.Diag(Loc, diag::note_value_initialization_here) << RD;
6781  return true;
6782  }
6783  }
6784 
6785  for (const auto &BI : RD->bases()) {
6786  if (DiagnoseUninitializedReference(S, BI.getLocStart(), BI.getType())) {
6787  S.Diag(Loc, diag::note_value_initialization_here) << RD;
6788  return true;
6789  }
6790  }
6791 
6792  return false;
6793 }
6794 
6795 
6796 //===----------------------------------------------------------------------===//
6797 // Diagnose initialization failures
6798 //===----------------------------------------------------------------------===//
6799 
6800 /// Emit notes associated with an initialization that failed due to a
6801 /// "simple" conversion failure.
6802 static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity,
6803  Expr *op) {
6804  QualType destType = entity.getType();
6805  if (destType.getNonReferenceType()->isObjCObjectPointerType() &&
6806  op->getType()->isObjCObjectPointerType()) {
6807 
6808  // Emit a possible note about the conversion failing because the
6809  // operand is a message send with a related result type.
6811 
6812  // Emit a possible note about a return failing because we're
6813  // expecting a related result type.
6814  if (entity.getKind() == InitializedEntity::EK_Result)
6816  }
6817 }
6818 
6819 static void diagnoseListInit(Sema &S, const InitializedEntity &Entity,
6820  InitListExpr *InitList) {
6821  QualType DestType = Entity.getType();
6822 
6823  QualType E;
6824  if (S.getLangOpts().CPlusPlus11 && S.isStdInitializerList(DestType, &E)) {
6826  E.withConst(),
6827  llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
6828  InitList->getNumInits()),
6830  InitializedEntity HiddenArray =
6832  return diagnoseListInit(S, HiddenArray, InitList);
6833  }
6834 
6835  if (DestType->isReferenceType()) {
6836  // A list-initialization failure for a reference means that we tried to
6837  // create a temporary of the inner type (per [dcl.init.list]p3.6) and the
6838  // inner initialization failed.
6839  QualType T = DestType->getAs<ReferenceType>()->getPointeeType();
6841  SourceLocation Loc = InitList->getLocStart();
6842  if (auto *D = Entity.getDecl())
6843  Loc = D->getLocation();
6844  S.Diag(Loc, diag::note_in_reference_temporary_list_initializer) << T;
6845  return;
6846  }
6847 
6848  InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
6849  /*VerifyOnly=*/false);
6850  assert(DiagnoseInitList.HadError() &&
6851  "Inconsistent init list check result.");
6852 }
6853 
6855  const InitializedEntity &Entity,
6856  const InitializationKind &Kind,
6857  ArrayRef<Expr *> Args) {
6858  if (!Failed())
6859  return false;
6860 
6861  QualType DestType = Entity.getType();
6862  switch (Failure) {
6864  // FIXME: Customize for the initialized entity?
6865  if (Args.empty()) {
6866  // Dig out the reference subobject which is uninitialized and diagnose it.
6867  // If this is value-initialization, this could be nested some way within
6868  // the target type.
6869  assert(Kind.getKind() == InitializationKind::IK_Value ||
6870  DestType->isReferenceType());
6871  bool Diagnosed =
6872  DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
6873  assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
6874  (void)Diagnosed;
6875  } else // FIXME: diagnostic below could be better!
6876  S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
6877  << SourceRange(Args.front()->getLocStart(), Args.back()->getLocEnd());
6878  break;
6879 
6880  case FK_ArrayNeedsInitList:
6881  S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
6882  break;
6884  S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
6885  break;
6887  S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
6888  break;
6890  S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
6891  break;
6893  S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
6894  break;
6896  S.Diag(Kind.getLocation(),
6897  diag::err_array_init_incompat_wide_string_into_wchar);
6898  break;
6899  case FK_ArrayTypeMismatch:
6901  S.Diag(Kind.getLocation(),
6902  (Failure == FK_ArrayTypeMismatch
6903  ? diag::err_array_init_different_type
6904  : diag::err_array_init_non_constant_array))
6905  << DestType.getNonReferenceType()
6906  << Args[0]->getType()
6907  << Args[0]->getSourceRange();
6908  break;
6909 
6911  S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
6912  << Args[0]->getSourceRange();
6913  break;
6914 
6916  DeclAccessPair Found;
6918  DestType.getNonReferenceType(),
6919  true,
6920  Found);
6921  break;
6922  }
6923 
6926  switch (FailedOverloadResult) {
6927  case OR_Ambiguous:
6928  if (Failure == FK_UserConversionOverloadFailed)
6929  S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
6930  << Args[0]->getType() << DestType
6931  << Args[0]->getSourceRange();
6932  else
6933  S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
6934  << DestType << Args[0]->getType()
6935  << Args[0]->getSourceRange();
6936 
6937  FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
6938  break;
6939 
6940  case OR_No_Viable_Function:
6941  if (!S.RequireCompleteType(Kind.getLocation(),
6942  DestType.getNonReferenceType(),
6943  diag::err_typecheck_nonviable_condition_incomplete,
6944  Args[0]->getType(), Args[0]->getSourceRange()))
6945  S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
6946  << Args[0]->getType() << Args[0]->getSourceRange()
6947  << DestType.getNonReferenceType();
6948 
6949  FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
6950  break;
6951 
6952  case OR_Deleted: {
6953  S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
6954  << Args[0]->getType() << DestType.getNonReferenceType()
6955  << Args[0]->getSourceRange();
6957  OverloadingResult Ovl
6958  = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best,
6959  true);
6960  if (Ovl == OR_Deleted) {
6961  S.NoteDeletedFunction(Best->Function);
6962  } else {
6963  llvm_unreachable("Inconsistent overload resolution?");
6964  }
6965  break;
6966  }
6967 
6968  case OR_Success:
6969  llvm_unreachable("Conversion did not fail!");
6970  }
6971  break;
6972 
6974  if (isa<InitListExpr>(Args[0])) {
6975  S.Diag(Kind.getLocation(),
6976  diag::err_lvalue_reference_bind_to_initlist)
6978  << DestType.getNonReferenceType()
6979  << Args[0]->getSourceRange();
6980  break;
6981  }
6982  // Intentional fallthrough
6983 
6985  S.Diag(Kind.getLocation(),
6987  ? diag::err_lvalue_reference_bind_to_temporary
6988  : diag::err_lvalue_reference_bind_to_unrelated)
6990  << DestType.getNonReferenceType()
6991  << Args[0]->getType()
6992  << Args[0]->getSourceRange();
6993  break;
6994 
6996  S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
6997  << DestType.getNonReferenceType() << Args[0]->getType()
6998  << Args[0]->getSourceRange();
6999  break;
7000 
7002  QualType SourceType = Args[0]->getType();
7003  QualType NonRefType = DestType.getNonReferenceType();
7004  Qualifiers DroppedQualifiers =
7005  SourceType.getQualifiers() - NonRefType.getQualifiers();
7006 
7007  S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
7008  << SourceType
7009  << NonRefType
7010  << DroppedQualifiers.getCVRQualifiers()
7011  << Args[0]->getSourceRange();
7012  break;
7013  }
7014 
7016  S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
7017  << DestType.getNonReferenceType()
7018  << Args[0]->isLValue()
7019  << Args[0]->getType()
7020  << Args[0]->getSourceRange();
7021  emitBadConversionNotes(S, Entity, Args[0]);
7022  break;
7023 
7024  case FK_ConversionFailed: {
7025  QualType FromType = Args[0]->getType();
7026  PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
7027  << (int)Entity.getKind()
7028  << DestType
7029  << Args[0]->isLValue()
7030  << FromType
7031  << Args[0]->getSourceRange();
7032  S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
7033  S.Diag(Kind.getLocation(), PDiag);
7034  emitBadConversionNotes(S, Entity, Args[0]);
7035  break;
7036  }
7037 
7039  // No-op. This error has already been reported.
7040  break;
7041 
7042  case FK_TooManyInitsForScalar: {
7043  SourceRange R;
7044 
7045  auto *InitList = dyn_cast<InitListExpr>(Args[0]);
7046  if (InitList && InitList->getNumInits() == 1)
7047  R = SourceRange(InitList->getInit(0)->getLocEnd(), InitList->getLocEnd());
7048  else
7049  R = SourceRange(Args.front()->getLocEnd(), Args.back()->getLocEnd());
7050 
7052  if (Kind.isCStyleOrFunctionalCast())
7053  S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
7054  << R;
7055  else
7056  S.Diag(Kind.getLocation(), diag::err_excess_initializers)
7057  << /*scalar=*/2 << R;
7058  break;
7059  }
7060 
7062  S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
7063  << DestType.getNonReferenceType() << Args[0]->getSourceRange();
7064  break;
7065 
7067  S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
7068  << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
7069  break;
7070 
7073  SourceRange ArgsRange;
7074  if (Args.size())
7075  ArgsRange = SourceRange(Args.front()->getLocStart(),
7076  Args.back()->getLocEnd());
7077 
7078  if (Failure == FK_ListConstructorOverloadFailed) {
7079  assert(Args.size() == 1 &&
7080  "List construction from other than 1 argument.");
7081  InitListExpr *InitList = cast<InitListExpr>(Args[0]);
7082  Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
7083  }
7084 
7085  // FIXME: Using "DestType" for the entity we're printing is probably
7086  // bad.
7087  switch (FailedOverloadResult) {
7088  case OR_Ambiguous:
7089  S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
7090  << DestType << ArgsRange;
7091  FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
7092  break;
7093 
7094  case OR_No_Viable_Function:
7095  if (Kind.getKind() == InitializationKind::IK_Default &&
7096  (Entity.getKind() == InitializedEntity::EK_Base ||
7097  Entity.getKind() == InitializedEntity::EK_Member) &&
7098  isa<CXXConstructorDecl>(S.CurContext)) {
7099  // This is implicit default initialization of a member or
7100  // base within a constructor. If no viable function was
7101  // found, notify the user that she needs to explicitly
7102  // initialize this base/member.
7103  CXXConstructorDecl *Constructor
7104  = cast<CXXConstructorDecl>(S.CurContext);
7105  if (Entity.getKind() == InitializedEntity::EK_Base) {
7106  S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
7107  << (Constructor->getInheritedConstructor() ? 2 :
7108  Constructor->isImplicit() ? 1 : 0)
7109  << S.Context.getTypeDeclType(Constructor->getParent())
7110  << /*base=*/0
7111  << Entity.getType();
7112 
7113  RecordDecl *BaseDecl
7114  = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
7115  ->getDecl();
7116  S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
7117  << S.Context.getTagDeclType(BaseDecl);
7118  } else {
7119  S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
7120  << (Constructor->getInheritedConstructor() ? 2 :
7121  Constructor->isImplicit() ? 1 : 0)
7122  << S.Context.getTypeDeclType(Constructor->getParent())
7123  << /*member=*/1
7124  << Entity.getName();
7125  S.Diag(Entity.getDecl()->getLocation(),
7126  diag::note_member_declared_at);
7127 
7128  if (const RecordType *Record
7129  = Entity.getType()->getAs<RecordType>())
7130  S.Diag(Record->getDecl()->getLocation(),
7131  diag::note_previous_decl)
7132  << S.Context.getTagDeclType(Record->getDecl());
7133  }
7134  break;
7135  }
7136 
7137  S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
7138  << DestType << ArgsRange;
7139  FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
7140  break;
7141 
7142  case OR_Deleted: {
7144  OverloadingResult Ovl
7145  = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
7146  if (Ovl != OR_Deleted) {
7147  S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
7148  << true << DestType << ArgsRange;
7149  llvm_unreachable("Inconsistent overload resolution?");
7150  break;
7151  }
7152 
7153  // If this is a defaulted or implicitly-declared function, then
7154  // it was implicitly deleted. Make it clear that the deletion was
7155  // implicit.
7156  if (S.isImplicitlyDeleted(Best->Function))
7157  S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
7158  << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
7159  << DestType << ArgsRange;
7160  else
7161  S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
7162  << true << DestType << ArgsRange;
7163 
7164  S.NoteDeletedFunction(Best->Function);
7165  break;
7166  }
7167 
7168  case OR_Success:
7169  llvm_unreachable("Conversion did not fail!");
7170  }
7171  }
7172  break;
7173 
7174  case FK_DefaultInitOfConst:
7175  if (Entity.getKind() == InitializedEntity::EK_Member &&
7176  isa<CXXConstructorDecl>(S.CurContext)) {
7177  // This is implicit default-initialization of a const member in
7178  // a constructor. Complain that it needs to be explicitly
7179  // initialized.
7180  CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
7181  S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
7182  << (Constructor->getInheritedConstructor() ? 2 :
7183  Constructor->isImplicit() ? 1 : 0)
7184  << S.Context.getTypeDeclType(Constructor->getParent())
7185  << /*const=*/1
7186  << Entity.getName();
7187  S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
7188  << Entity.getName();
7189  } else {
7190  S.Diag(Kind.getLocation(), diag::err_default_init_const)
7191  << DestType << (bool)DestType->getAs<RecordType>();
7192  }
7193  break;
7194 
7195  case FK_Incomplete:
7196  S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
7197  diag::err_init_incomplete_type);
7198  break;
7199 
7201  // Run the init list checker again to emit diagnostics.
7202  InitListExpr *InitList = cast<InitListExpr>(Args[0]);
7203  diagnoseListInit(S, Entity, InitList);
7204  break;
7205  }
7206 
7207  case FK_PlaceholderType: {
7208  // FIXME: Already diagnosed!
7209  break;
7210  }
7211 
7212  case FK_ExplicitConstructor: {
7213  S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
7214  << Args[0]->getSourceRange();
7216  OverloadingResult Ovl
7217  = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
7218  (void)Ovl;
7219  assert(Ovl == OR_Success && "Inconsistent overload resolution");
7220  CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
7221  S.Diag(CtorDecl->getLocation(), diag::note_constructor_declared_here);
7222  break;
7223  }
7224  }
7225 
7226  PrintInitLocationNote(S, Entity);
7227  return true;
7228 }
7229 
7230 void InitializationSequence::dump(raw_ostream &OS) const {
7231  switch (SequenceKind) {
7232  case FailedSequence: {
7233  OS << "Failed sequence: ";
7234  switch (Failure) {
7236  OS << "too many initializers for reference";
7237  break;
7238 
7239  case FK_ArrayNeedsInitList:
7240  OS << "array requires initializer list";
7241  break;
7242 
7244  OS << "array requires initializer list or string literal";
7245  break;
7246 
7248  OS << "array requires initializer list or wide string literal";
7249  break;
7250 
7252  OS << "narrow string into wide char array";
7253  break;
7254 
7256  OS << "wide string into char array";
7257  break;
7258 
7260  OS << "incompatible wide string into wide char array";
7261  break;
7262 
7263  case FK_ArrayTypeMismatch:
7264  OS << "array type mismatch";
7265  break;
7266 
7268  OS << "non-constant array initializer";
7269  break;
7270 
7272  OS << "address of overloaded function failed";
7273  break;
7274 
7276  OS << "overload resolution for reference initialization failed";
7277  break;
7278 
7280  OS << "non-const lvalue reference bound to temporary";
7281  break;
7282 
7284  OS << "non-const lvalue reference bound to unrelated type";
7285  break;
7286 
7288  OS << "rvalue reference bound to an lvalue";
7289  break;
7290 
7292  OS << "reference initialization drops qualifiers";
7293  break;
7294 
7296  OS << "reference initialization failed";
7297  break;
7298 
7299  case FK_ConversionFailed:
7300  OS << "conversion failed";
7301  break;
7302 
7304  OS << "conversion from property failed";
7305  break;
7306 
7308  OS << "too many initializers for scalar";
7309  break;
7310 
7312  OS << "referencing binding to initializer list";
7313  break;
7314 
7316  OS << "initializer list for non-aggregate, non-scalar type";
7317  break;
7318 
7320  OS << "overloading failed for user-defined conversion";
7321  break;
7322 
7324  OS << "constructor overloading failed";
7325  break;
7326 
7327  case FK_DefaultInitOfConst:
7328  OS << "default initialization of a const variable";
7329  break;
7330 
7331  case FK_Incomplete:
7332  OS << "initialization of incomplete type";
7333  break;
7334 
7336  OS << "list initialization checker failure";
7337  break;
7338 
7340  OS << "variable length array has an initializer";
7341  break;
7342 
7343  case FK_PlaceholderType:
7344  OS << "initializer expression isn't contextually valid";
7345  break;
7346 
7348  OS << "list constructor overloading failed";
7349  break;
7350 
7352  OS << "list copy initialization chose explicit constructor";
7353  break;
7354  }
7355  OS << '\n';
7356  return;
7357  }
7358 
7359  case DependentSequence:
7360  OS << "Dependent sequence\n";
7361  return;
7362 
7363  case NormalSequence:
7364  OS << "Normal sequence: ";
7365  break;
7366  }
7367 
7368  for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
7369  if (S != step_begin()) {
7370  OS << " -> ";
7371  }
7372 
7373  switch (S->Kind) {
7375  OS << "resolve address of overloaded function";
7376  break;
7377 
7379  OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")";
7380  break;
7381 
7383  OS << "derived-to-base case (xvalue" << S->Type.getAsString() << ")";
7384  break;
7385 
7387  OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")";
7388  break;
7389 
7390  case SK_BindReference:
7391  OS << "bind reference to lvalue";
7392  break;
7393 
7395  OS << "bind reference to a temporary";
7396  break;
7397 
7399  OS << "extraneous C++03 copy to temporary";
7400  break;
7401 
7402  case SK_UserConversion:
7403  OS << "user-defined conversion via " << *S->Function.Function;
7404  break;
7405 
7407  OS << "qualification conversion (rvalue)";
7408  break;
7409 
7411  OS << "qualification conversion (xvalue)";
7412  break;
7413 
7415  OS << "qualification conversion (lvalue)";
7416  break;
7417 
7418  case SK_AtomicConversion:
7419  OS << "non-atomic-to-atomic conversion";
7420  break;
7421 
7422  case SK_LValueToRValue:
7423  OS << "load (lvalue to rvalue)";
7424  break;
7425 
7426  case SK_ConversionSequence:
7427  OS << "implicit conversion sequence (";
7428  S->ICS->dump(); // FIXME: use OS
7429  OS << ")";
7430  break;
7431 
7433  OS << "implicit conversion sequence with narrowing prohibited (";
7434  S->ICS->dump(); // FIXME: use OS
7435  OS << ")";
7436  break;
7437 
7438  case SK_ListInitialization:
7439  OS << "list aggregate initialization";
7440  break;
7441 
7442  case SK_UnwrapInitList:
7443  OS << "unwrap reference initializer list";
7444  break;
7445 
7446  case SK_RewrapInitList:
7447  OS << "rewrap reference initializer list";
7448  break;
7449 
7451  OS << "constructor initialization";
7452  break;
7453 
7455  OS << "list initialization via constructor";
7456  break;
7457 
7458  case SK_ZeroInitialization:
7459  OS << "zero initialization";
7460  break;
7461 
7462  case SK_CAssignment:
7463  OS << "C assignment";
7464  break;
7465 
7466  case SK_StringInit:
7467  OS << "string initialization";
7468  break;
7469 
7471  OS << "Objective-C object conversion";
7472  break;
7473 
7474  case SK_ArrayInit:
7475  OS << "array initialization";
7476  break;
7477 
7479  OS << "parenthesized array initialization";
7480  break;
7481 
7483  OS << "pass by indirect copy and restore";
7484  break;
7485 
7487  OS << "pass by indirect restore";
7488  break;
7489 
7490  case SK_ProduceObjCObject:
7491  OS << "Objective-C object retension";
7492  break;
7493 
7494  case SK_StdInitializerList:
7495  OS << "std::initializer_list from initializer list";
7496  break;
7497 
7499  OS << "list initialization from std::initializer_list";
7500  break;
7501 
7502  case SK_OCLSamplerInit:
7503  OS << "OpenCL sampler_t from integer constant";
7504  break;
7505 
7506  case SK_OCLZeroEvent:
7507  OS << "OpenCL event_t from zero";
7508  break;
7509  }
7510 
7511  OS << " [" << S->Type.getAsString() << ']';
7512  }
7513 
7514  OS << '\n';
7515 }
7516 
7518  dump(llvm::errs());
7519 }
7520 
7522  const ImplicitConversionSequence &ICS,
7523  QualType PreNarrowingType,
7524  QualType EntityType,
7525  const Expr *PostInit) {
7526  const StandardConversionSequence *SCS = nullptr;
7527  switch (ICS.getKind()) {
7529  SCS = &ICS.Standard;
7530  break;
7532  SCS = &ICS.UserDefined.After;
7533  break;
7537  return;
7538  }
7539 
7540  // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
7541  APValue ConstantValue;
7542  QualType ConstantType;
7543  switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
7544  ConstantType)) {
7545  case NK_Not_Narrowing:
7546  // No narrowing occurred.
7547  return;
7548 
7549  case NK_Type_Narrowing:
7550  // This was a floating-to-integer conversion, which is always considered a
7551  // narrowing conversion even if the value is a constant and can be
7552  // represented exactly as an integer.
7553  S.Diag(PostInit->getLocStart(),
7554  (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7555  ? diag::warn_init_list_type_narrowing
7556  : diag::ext_init_list_type_narrowing)
7557  << PostInit->getSourceRange()
7558  << PreNarrowingType.getLocalUnqualifiedType()
7559  << EntityType.getLocalUnqualifiedType();
7560  break;
7561 
7562  case NK_Constant_Narrowing:
7563  // A constant value was narrowed.
7564  S.Diag(PostInit->getLocStart(),
7565  (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7566  ? diag::warn_init_list_constant_narrowing
7567  : diag::ext_init_list_constant_narrowing)
7568  << PostInit->getSourceRange()
7569  << ConstantValue.getAsString(S.getASTContext(), ConstantType)
7570  << EntityType.getLocalUnqualifiedType();
7571  break;
7572 
7573  case NK_Variable_Narrowing:
7574  // A variable's value may have been narrowed.
7575  S.Diag(PostInit->getLocStart(),
7576  (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7577  ? diag::warn_init_list_variable_narrowing
7578  : diag::ext_init_list_variable_narrowing)
7579  << PostInit->getSourceRange()
7580  << PreNarrowingType.getLocalUnqualifiedType()
7581  << EntityType.getLocalUnqualifiedType();
7582  break;
7583  }
7584 
7585  SmallString<128> StaticCast;
7586  llvm::raw_svector_ostream OS(StaticCast);
7587  OS << "static_cast<";
7588  if (const TypedefType *TT = EntityType->getAs<TypedefType>()) {
7589  // It's important to use the typedef's name if there is one so that the
7590  // fixit doesn't break code using types like int64_t.
7591  //
7592  // FIXME: This will break if the typedef requires qualification. But
7593  // getQualifiedNameAsString() includes non-machine-parsable components.
7594  OS << *TT->getDecl();
7595  } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>())
7596  OS << BT->getName(S.getLangOpts());
7597  else {
7598  // Oops, we didn't find the actual type of the variable. Don't emit a fixit
7599  // with a broken cast.
7600  return;
7601  }
7602  OS << ">(";
7603  S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_silence)
7604  << PostInit->getSourceRange()
7605  << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str())
7607  S.getLocForEndOfToken(PostInit->getLocEnd()), ")");
7608 }
7609 
7610 //===----------------------------------------------------------------------===//
7611 // Initialization helper functions
7612 //===----------------------------------------------------------------------===//
7613 bool
7615  ExprResult Init) {
7616  if (Init.isInvalid())
7617  return false;
7618 
7619  Expr *InitE = Init.get();
7620  assert(InitE && "No initialization expression");
7621 
7622  InitializationKind Kind
7623  = InitializationKind::CreateCopy(InitE->getLocStart(), SourceLocation());
7624  InitializationSequence Seq(*this, Entity, Kind, InitE);
7625  return !Seq.Failed();
7626 }
7627 
7628 ExprResult
7630  SourceLocation EqualLoc,
7631  ExprResult Init,
7632  bool TopLevelOfInitList,
7633  bool AllowExplicit) {
7634  if (Init.isInvalid())
7635  return ExprError();
7636 
7637  Expr *InitE = Init.get();
7638  assert(InitE && "No initialization expression?");
7639 
7640  if (EqualLoc.isInvalid())
7641  EqualLoc = InitE->getLocStart();
7642 
7643  InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
7644  EqualLoc,
7645  AllowExplicit);
7646  InitializationSequence Seq(*this, Entity, Kind, InitE, TopLevelOfInitList);
7647 
7648  ExprResult Result = Seq.Perform(*this, Entity, Kind, InitE);
7649 
7650  return Result;
7651 }
unsigned getNumElements() const
Definition: Type.h:2724
LValueClassification ClassifyLValue(ASTContext &Ctx) const
Reasons why an expression might not be an l-value.
Represents a single C99 designator.
Definition: Expr.h:4035
Perform a derived-to-base cast, producing an lvalue.
Defines the clang::ASTContext interface.
unsigned getNumInits() const
Definition: Expr.h:3789
SourceLocation getEnd() const
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:64
static bool performReferenceExtension(Expr *Init, const InitializedEntity *ExtendingEntity)
Definition: SemaInit.cpp:5782
InitListExpr * WrappingSyntacticList
When Kind = SK_RewrapInitList, the syntactic form of the wrapping list.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchers.h:1110
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
iterator begin() const
Definition: DeclBase.h:1070
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
bool Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr * > Args)
Diagnose an potentially-invalid initialization sequence.
Definition: SemaInit.cpp:6854
void SetZeroInitializationFixit(const std::string &Fixit, SourceLocation L)
Call for initializations are invalid but that would be valid zero initialzations if Fixit was applied...
bool isConstantArrayType() const
Definition: Type.h:5274
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:206
DesignatorKind getKind() const
Definition: Designator.h:69
Simple class containing the result of Sema::CorrectTypo.
base_class_range bases()
Definition: DeclCXX.h:713
bool isInvalid() const
Definition: Ownership.h:159
unsigned Index
When Kind == EK_ArrayElement, EK_VectorElement, or EK_ComplexElement, the index of the array or vecto...
bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType)
bool isMacroID() const
bool isCharType() const
Definition: Type.cpp:1633
step_iterator step_end() const
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2216
Produce an Objective-C object pointer.
A cast other than a C-style cast.
Definition: Sema.h:8030
DestructionKind isDestructedType() const
Definition: Type.h:999
QualType getCallResultType() const
Determine the type of an expression that calls this function.
Definition: Decl.h:2007
void AddOCLZeroEventStep(QualType T)
Add a step to initialize an OpenCL event_t from a NULL constant.
Definition: SemaInit.cpp:3225
Initializing char array with wide string literal.
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:252
Perform an implicit conversion sequence without narrowing.
An initialization that "converts" an Objective-C object (not a point to an object) to another Objecti...
IdentifierInfo * getIdentifier() const
Definition: Decl.h:163
InvalidICRKind
The non-zero enum values here are indexes into diagnostic alternatives.
Definition: SemaInit.cpp:4608
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
Definition: SemaExpr.cpp:5661
static ExprResult CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value)
Definition: SemaInit.cpp:2646
CanQualType Char32Ty
Definition: ASTContext.h:824
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2524
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1581
const LangOptions & getLangOpts() const
Definition: Sema.h:1019
static void TryReferenceInitializationCore(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, QualType cv1T1, QualType T1, Qualifiers T1Quals, QualType cv2T2, QualType T2, Qualifiers T2Quals, InitializationSequence &Sequence)
Reference initialization without resolving overloaded functions.
Definition: SemaInit.cpp:4066
Perform a qualification conversion, producing an rvalue.
SmallVectorImpl< Step >::const_iterator step_iterator
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Expr * getInit() const
Retrieve the initializer value.
Definition: Expr.h:4225
ActionResult< Expr * > ExprResult
Definition: Ownership.h:252
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
Definition: SemaExpr.cpp:4137
std::set< Replacement > Replacements
A set of Replacements. FIXME: Change to a vector and deduplicate in the RefactoringTool.
Definition: Replacement.h:141
static DesignatedInitExpr * CloneDesignatedInitExpr(Sema &SemaRef, DesignatedInitExpr *DIE)
Definition: SemaInit.cpp:1888
bool isRecordType() const
Definition: Type.h:5289
UserDefinedConversionSequence UserDefined
Definition: Overload.h:415
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1088
unsigned size() const
Returns the number of designators in this initializer.
Definition: Expr.h:4161
AccessSpecifier getAccess() const
uintptr_t Base
When Kind == EK_Base, the base specifier that provides the base class. The lower bit specifies whethe...
AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, const InitializedEntity &Entity, AccessSpecifier Access, bool IsCopyBindingRefToTemp=false)
Checks access to a constructor.
void setType(QualType t)
Definition: Expr.h:126
AssignConvertType
Definition: Sema.h:8140
Not a narrowing conversion.
Definition: Overload.h:107
llvm::iterator_range< conversion_iterator > getVisibleConversionFunctions()
Get all conversion functions visible in current class, including conversion function templates...
Definition: DeclCXX.cpp:1177
bool hasFlexibleArrayMember() const
Definition: Decl.h:3279
bool CanPerformCopyInitialization(const InitializedEntity &Entity, ExprResult Init)
Definition: SemaInit.cpp:7614
std::string getAsString() const
Definition: Type.h:897
PtrTy get() const
Definition: Ownership.h:163
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
bool isInStdNamespace() const
Definition: DeclBase.cpp:265
SourceLocation getEqualLoc() const
Retrieve the location of the equal sign for copy initialization (if present).
static bool tryObjCWritebackConversion(Sema &S, InitializationSequence &Sequence, const InitializedEntity &Entity, Expr *Initializer)
Definition: SemaInit.cpp:4712
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
Definition: ASTContext.h:2009
The entity being initialized is a variable.
InitListExpr * getSyntacticForm() const
Definition: Expr.h:3891
const Expr * getInit() const
Definition: Decl.h:1068
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:400
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:47
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1075
Overloading for a user-defined conversion failed.
Ambiguous candidates found.
Definition: Overload.h:43
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:83
A container of type source information.
Definition: Decl.h:60
void AddAddressOverloadResolutionStep(FunctionDecl *Function, DeclAccessPair Found, bool HadMultipleCandidates)
Add a new step in the initialization that resolves the address of an overloaded function to a specifi...
Definition: SemaInit.cpp:3029
Perform a derived-to-base cast, producing an xvalue.
The entity being initialized is a base member subobject.
bool isFunctionalCast() const
Determine whether this is a functional-style cast.
List-copy-initialization chose an explicit constructor.
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclBase.h:368
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2147
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
Definition: Expr.cpp:2912
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:3746
bool isSpelledAsLValue() const
Definition: Type.h:2282
SourceLocation getDotLoc() const
Definition: Designator.h:79
const llvm::APInt & getSize() const
Definition: Type.h:2472
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
The entity being initialized is a function parameter; function is member of group of audited CF APIs...
static const InitializedEntity * getEntityForTemporaryLifetimeExtension(const InitializedEntity *Entity, const InitializedEntity *FallbackDecl=nullptr)
Definition: SemaInit.cpp:5709
Initialize an OpenCL sampler from an integer.
EntityKind getKind() const
Determine the kind of initialization.
static void LookupCopyAndMoveConstructors(Sema &S, OverloadCandidateSet &CandidateSet, CXXRecordDecl *Class, Expr *CurInitExpr)
Look for copy and move constructors and constructor templates, for copying an object via direct-initi...
Definition: SemaInit.cpp:5201
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
ExprResult PerformObjectArgumentInitialization(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, CXXMethodDecl *Method)
static void TryUserDefinedConversion(Sema &S, QualType DestType, const InitializationKind &Kind, Expr *Initializer, InitializationSequence &Sequence, bool TopLevelOfInitList)
Attempt a user-defined conversion between two types (C++ [dcl.init]), which enumerates all conversion...
Definition: SemaInit.cpp:4431
void AddCAssignmentStep(QualType T)
Add a C assignment step.
Definition: SemaInit.cpp:3160
DiagnosticsEngine & Diags
Definition: Sema.h:297
const Expr * getCallee() const
Definition: Expr.h:2188
static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT, ASTContext &Context)
Check whether the array of type AT can be initialized by the Init expression by means of string initi...
Definition: SemaInit.cpp:59
AccessSpecifier getAccess() const
Definition: DeclBase.h:416
static void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity, SourceRange Braces)
Definition: SemaInit.cpp:828
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
SourceRange getParenRange() const
Retrieve the source range containing the locations of the open and closing parentheses for value and ...
SourceLocation getLBracketLoc() const
Definition: Designator.h:103
field_iterator field_begin() const
Definition: Decl.cpp:3629
void resizeInits(const ASTContext &Context, unsigned NumInits)
Specify the number of initializers.
Definition: Expr.cpp:1909
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1701
void setInit(unsigned Init, Expr *expr)
Definition: Expr.h:3804
Expr * IgnoreImplicit() LLVM_READONLY
Definition: Expr.h:694
Non-const lvalue reference binding to an lvalue of unrelated type.
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:492
step_iterator step_begin() const
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Definition: DeclCXX.cpp:1797
SourceLocation getThrowLoc() const
Determine the location of the 'throw' keyword when initializing an exception object.
void setBegin(SourceLocation b)
Perform a derived-to-base cast, producing an rvalue.
void AddReferenceBindingStep(QualType T, bool BindingTemporary)
Add a new step binding a reference to an object.
Definition: SemaInit.cpp:3053
static InitializationKind CreateDirectList(SourceLocation InitLoc)
static DesignatedInitExpr * Create(const ASTContext &C, Designator *Designators, unsigned NumDesignators, ArrayRef< Expr * > IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)
Definition: Expr.cpp:3936
bool allowsNRVO() const
Determine whether this initialization allows the named return value optimization, which also applies ...
Definition: SemaInit.cpp:2860
void setElementIndex(unsigned Index)
If this is already the initializer for an array or vector element, sets the element index...
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false)
Definition: SemaExpr.cpp:7114
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1334
The entity being initialized is a temporary object.
bool isObjCRetainableType() const
Definition: Type.cpp:3542
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
Definition: Expr.cpp:3225
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isUnionType() const
Definition: Type.cpp:390
Expr * getArrayIndex(const Designator &D) const
Definition: Expr.cpp:3991
bool isVoidType() const
Definition: Type.h:5426
bool allowExplicitConversionFunctionsInRefBinding() const
Retrieve whether this initialization allows the use of explicit conversion functions when binding a r...
bool isLValue() const
Definition: Expr.h:351
static void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr, bool IsReturnStmt)
Provide warnings when std::move is used on construction.
Definition: SemaInit.cpp:5924
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
Definition: Expr.cpp:3371
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, AssignmentAction Action, bool AllowExplicit=false)
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
Expr * IgnoreImpCasts() LLVM_READONLY
Definition: Expr.h:2803
Expr * FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
void InitializeFrom(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, bool TopLevelOfInitList)
Definition: SemaInit.cpp:4801
Represents a C99 designated initializer expression.
Definition: Expr.h:3961
Construct a std::initializer_list from an initializer list.
bool isScalarType() const
Definition: Type.h:5461
Expr * getSubExpr(unsigned Idx) const
Definition: Expr.h:4239
void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic)
Add steps to unwrap a initializer list for a reference around a single element and rewrap it at the e...
Definition: SemaInit.cpp:3232
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init.ref]).
Definition: SemaInit.cpp:2976
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:89
The results of name lookup within a DeclContext. This is either a single result (with no stable stora...
Definition: DeclBase.h:1034
A C-style cast.
Definition: Sema.h:8026
ImplicitConversionSequence * ICS
When Kind = SK_ConversionSequence, the implicit conversion sequence.
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
bool isReferenceType() const
Definition: Type.h:5241
DeclaratorDecl * getDecl() const
Retrieve the variable, parameter, or field being initialized.
Definition: SemaInit.cpp:2831
QualType getReturnType() const
Definition: Decl.h:1997
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:882
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:4279
SourceLocation getReturnLoc() const
Determine the location of the 'return' keyword when initializing the result of a function call...
Converting between two Objective-C object types, which can occur when performing reference binding to...
static bool isLibstdcxxPointerReturnFalseHack(Sema &S, const InitializedEntity &Entity, const Expr *Init)
Definition: SemaInit.cpp:4596
bool isPRValue() const
Definition: Expr.h:354
static void warnOnLifetimeExtension(Sema &S, const InitializedEntity &Entity, const Expr *Init, bool IsInitializerList, const ValueDecl *ExtendingDecl)
Definition: SemaInit.cpp:5884
Rewrap the single-element initializer list for a reference.
unsigned getCVRQualifiers() const
Definition: Type.h:248
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1871
void AddOCLSamplerInitStep(QualType T)
Add a step to initialize an OpenCL sampler from an integer constant.
Definition: SemaInit.cpp:3218
TypeSourceInfo * getTypeSourceInfo() const
Retrieve complete type-source information for the object being constructed, if known.
bool refersToVectorElement() const
Returns whether this expression refers to a vector element.
Definition: Expr.cpp:3412
bool ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&SrcExpr)
Definition: SemaExpr.cpp:11598
void AddConversionCandidate(CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit)
void SetOverloadFailure(FailureKind Failure, OverloadingResult Result)
Note that this initialization sequence failed due to failed overload resolution.
Definition: SemaInit.cpp:3247
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1114
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:1896
SourceLocation getRParenLoc() const
Definition: Expr.h:2283
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:200
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:95
Perform initialization via a constructor taking a single std::initializer_list argument.
static bool shouldDestroyTemporary(const InitializedEntity &Entity)
Whether the given entity, when initialized with an object created for that initialization, requires destruction.
Definition: SemaInit.cpp:5172
Describes an C or C++ initializer list.
Definition: Expr.h:3759
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:518
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:323
static void ExpandAnonymousFieldDesignator(Sema &SemaRef, DesignatedInitExpr *DIE, unsigned DesigIdx, IndirectFieldDecl *IndirectField)
Expand a field designator that refers to a member of an anonymous struct or union into a series of fi...
Definition: SemaInit.cpp:1860
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
const LangOptions & getLangOpts() const
Definition: ASTContext.h:533
StepKind Kind
The kind of conversion or initialization step we are taking.
bool isImplicit() const
Definition: DeclBase.h:503
SourceRange getRange() const
Retrieve the source range that covers the initialization.
Succeeded, but refers to a deleted function.
Definition: Overload.h:44
ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, bool &DerivedToBase, bool &ObjCConversion, bool &ObjCLifetimeConversion)
unsigned getMinRequiredArguments() const
Definition: Decl.cpp:2694
OverloadCandidateSet & getFailedCandidateSet()
Retrieve a reference to the candidate set when overload resolution fails.
const CXXRecordDecl * getParent() const
Definition: DeclCXX.h:1817
bool isDefaulted() const
Definition: Decl.h:1805
An x-value expression is a reference to an object with independent storage but which can be "moved"...
Definition: Specifiers.h:104
field_range fields() const
Definition: Decl.h:3349
bool isObjCLifetimeType() const
Definition: Type.cpp:3561
const ArrayType * getAsArrayType(QualType T) const
const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr * > &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const
Definition: Expr.cpp:54
SourceLocation getRBraceLoc() const
Definition: Expr.h:3884
bool isValueDependent() const
Definition: Expr.h:146
Variable-length array must not have an initializer.
RecordDecl * getDecl() const
Definition: Type.h:3527
ImplicitConversionKind Second
Definition: Overload.h:139
Initialization of an incomplete type.
The entity being initialized is a non-static data member subobject.
static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool isImplicit=false)
Create a value initialization.
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:8022
bool isUnsignedIntegerType() const
Definition: Type.cpp:1723
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > IL, Expr *Step, Expr *CalcStep)
Creates clause with a list of variables VL and a linear step Step.
A narrowing conversion, because a constant expression got narrowed.
Definition: Overload.h:113
Unwrap the single-element initializer list for a reference.
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
void AddParenthesizedArrayInitStep(QualType T)
Add a parenthesized array initialization step.
Definition: SemaInit.cpp:3188
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence...
Definition: SemaInit.cpp:6024
chain_iterator chain_begin() const
Definition: Decl.h:2511
The entity being initialized is an element of a vector. or vector.
bool CanUseDecl(NamedDecl *D)
Determine whether the use of this declaration is valid, without emitting diagnostics.
Definition: SemaExpr.cpp:51
bool isAmbiguous() const
Determine whether this initialization failed due to an ambiguity.
Definition: SemaInit.cpp:2980
bool isIncompleteType(NamedDecl **Def=nullptr) const
Def If non-NULL, and the type refers to some kind of declaration that can be completed (such as a C s...
Definition: Type.cpp:1869
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1032
bool hasConst() const
Definition: Type.h:226
NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted, APValue &ConstantValue, QualType &ConstantType) const
Perform initialization via a constructor.
Perform a user-defined conversion, either via a conversion function or via a constructor.
bool isExtVectorType() const
Definition: Type.h:5301
The entity being initialized is a function parameter.
NamedDecl *const * chain_iterator
Definition: Decl.h:2507
bool ExprNeedsCleanups
Definition: Sema.h:413
QualType getType() const
Definition: Decl.h:538
bool isInvalid() const
bool isUnnamedBitfield() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:2336
static void diagnoseListInit(Sema &S, const InitializedEntity &Entity, InitListExpr *InitList)
Definition: SemaInit.cpp:6819
field_iterator field_end() const
Definition: Decl.h:3352
const ArrayType * getAsArrayTypeUnsafe() const
Definition: Type.h:5572
bool isUnion() const
Definition: Decl.h:2906
Perform an implicit conversion sequence.
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2333
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:258
void setField(FieldDecl *FD)
Definition: Expr.h:4097
Overloading for list-initialization by constructor failed.
Perform list-initialization without a constructor.
void EmitRelatedResultTypeNoteForReturn(QualType destType)
Given that we had incompatible pointer types in a return statement, check whether we're in a method w...
IdentifierInfo * getFieldName() const
Definition: Expr.cpp:3861
A functional-style cast.
Definition: Sema.h:8028
void AddObjCObjectConversionStep(QualType T)
Add an Objective-C object conversion step, which is always a no-op.
Definition: SemaInit.cpp:3174
Qualifiers::ObjCLifetime getObjCLifetime() const
getObjCLifetime - Returns lifetime attribute of this type.
Definition: Type.h:976
Cannot resolve the address of an overloaded function.
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL...
Represents a ValueDecl that came out of a declarator. Contains type source information through TypeSo...
Definition: Decl.h:586
CastKind
CastKind - The kind of operation required for a conversion.
The return type of classify(). Represents the C++11 expression taxonomy.
Definition: Expr.h:302
void AddStdInitializerListConstructionStep(QualType T)
Add a step to construct a std::initializer_list object from an initializer list.
Definition: SemaInit.cpp:3211
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a member subobject.
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1737
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
ASTContext * Context
A narrowing conversion by virtue of the source and destination types.
Definition: Overload.h:110
The entity being initialized is a field of block descriptor for the copied-in c++ object...
ImplicitConversionSequence TryImplicitConversion(Expr *From, QualType ToType, bool SuppressUserConversions, bool AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion)
bool isObjCWritebackConversion(QualType FromType, QualType ToType, QualType &ConvertedType)
Determine whether this is an Objective-C writeback conversion, used for parameter passing when perfor...
bool hasVolatile() const
Definition: Type.h:233
SourceLocation getEllipsisLoc() const
Definition: Designator.h:121
designators_iterator designators_begin()
Definition: Expr.h:4165
int * Depth
virtual bool ValidateCandidate(const TypoCorrection &candidate)
Simple predicate used by the default RankCandidate to determine whether to return an edit distance of...
Initializing wide char array with incompatible wide string literal.
The entity being initialized is the real or imaginary part of a complex number.
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:1861
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.h:4136
void setRBraceLoc(SourceLocation Loc)
Definition: Expr.h:3885
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:3972
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:92
bool isAnyComplexType() const
Definition: Type.h:5295
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: ExprCXX.h:3790
StandardConversionSequence After
Definition: Overload.h:265
static void updateStringLiteralType(Expr *E, QualType Ty)
Definition: SemaInit.cpp:133
uintptr_t Parameter
When Kind == EK_Parameter, the ParmVarDecl, with the low bit indicating whether the parameter is "con...
The entity being initialized is an object (or array of objects) allocated via new.
Perform a qualification conversion, producing an xvalue.
void setSyntacticForm(InitListExpr *Init)
Definition: Expr.h:3895
Represents a C++ functional cast expression that builds a temporary object.
Definition: ExprCXX.h:1295
SourceLocation getLBraceLoc() const
Definition: Expr.h:3882
static void performLifetimeExtension(Expr *Init, const InitializedEntity *ExtendingEntity)
Definition: SemaInit.cpp:5828
bool isAtomicType() const
Definition: Type.h:5314
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2358
Initializing a wide char array with narrow string literal.
void ClearExprs(Sema &Actions)
Definition: Designator.h:201
bool CheckObjCBridgeRelatedConversions(SourceLocation Loc, QualType DestType, QualType SrcType, Expr *&SrcExpr)
void AddProduceObjCObjectStep(QualType T)
Add a step to "produce" an Objective-C object (by retaining it).
Definition: SemaInit.cpp:3204
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:743
Passing zero to a function where OpenCL event_t is expected.
void AddConstructorInitializationStep(CXXConstructorDecl *Constructor, AccessSpecifier Access, QualType T, bool HadMultipleCandidates, bool FromInitList, bool AsInitList)
Add a constructor-initialization step.
Definition: SemaInit.cpp:3137
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, bool AllowFold=true)
Definition: SemaExpr.cpp:11869
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:1967
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:1968
SourceLocation getEqualOrColonLoc() const
Retrieve the location of the '=' that precedes the initializer value itself, if present.
Definition: Expr.h:4216
bool isInitListConstructor(const CXXConstructorDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init.list]p2.
Resolve the address of an overloaded function to a specific function declaration. ...
Expr * getArrayRangeStart(const Designator &D) const
Definition: Expr.cpp:3997
DeclContext * getDeclContext()
Definition: DeclBase.h:381
Overload resolution succeeded.
Definition: Overload.h:41
void AddArrayInitStep(QualType T)
Add an array initialization step.
Definition: SemaInit.cpp:3181
The entity being initialized is an exception object that is being thrown.
bool isFloatingType() const
Definition: Type.cpp:1760
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
Definition: SemaExpr.cpp:11630
ExprResult CheckPlaceholderExpr(Expr *E)
Definition: SemaExpr.cpp:14231
struct F Function
When Kind == SK_ResolvedOverloadedFunction or Kind == SK_UserConversion, the function that the expres...
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
Definition: Expr.h:376
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
ReferenceCompareResult
Definition: Sema.h:8369
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:6354
Defines the clang::TypeLoc interface and its subclasses.
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:662
bool isExplicit() const
Determine whether this constructor was marked "explicit" or not.
Definition: DeclCXX.h:2187
ObjCMethodDecl * getMethodDecl() const
Retrieve the ObjectiveC method being initialized.
void NoteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation())
bool isDependentType() const
Definition: Type.h:1727
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
Definition: Expr.h:421
StandardConversionSequence Standard
Definition: Overload.h:411
bool IsDerivedFrom(QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
static void TryDefaultInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitializationSequence &Sequence)
Attempt default initialization (C++ [dcl.init]p6).
Definition: SemaInit.cpp:4391
void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false)
Add a C++ function template specialization as a candidate in the candidate set, using template argume...
Initializer has a placeholder type which cannot be resolved by initialization.
SmallVector< ActiveTemplateInstantiation, 16 > ActiveTemplateInstantiations
List of active template instantiations.
Definition: Sema.h:6518
static void TryReferenceInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, InitializationSequence &Sequence)
Attempt reference initialization (C++0x [dcl.init.ref])
Definition: SemaInit.cpp:3989
DeclarationName getDeclName() const
Definition: Decl.h:189
const IdentifierInfo * getField() const
Definition: Designator.h:74
FailureKind getFailureKind() const
Determine why initialization failed.
ValueDecl * getDecl()
Definition: Expr.h:994
bool isGLValue() const
Definition: Expr.h:253
QualType getElementType() const
Definition: Type.h:2723
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2405
void AddStringInitStep(QualType T)
Add a string init step.
Definition: SemaInit.cpp:3167
The result type of a method or function.
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:702
InitKind getKind() const
Determine the initialization kind.
void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
QualType getWideCharType() const
Return the type of wide characters. In C++, this returns the unique wchar_t type. In C99...
Definition: ASTContext.h:1264
void AddZeroInitializationStep(QualType T)
Add a zero-initialization step.
Definition: SemaInit.cpp:3153
bool hasUninitializedReferenceMember() const
Whether this class or any of its subobjects has any members of reference type which would make value-...
Definition: DeclCXX.h:1117
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
unsigned getNumSubExprs() const
Retrieve the total number of subexpressions in this designated initializer expression, including the actual initialized value and any expressions that occur within array and array-range designators.
Definition: Expr.h:4237
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
InitListExpr * getUpdater() const
Definition: Expr.h:4332
FailureKind
Describes why initialization failed.
static void TryListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitListExpr *InitList, InitializationSequence &Sequence)
Attempt list initialization (C++0x [dcl.init.list])
Definition: SemaInit.cpp:3657
bool isArrayRangeDesignator() const
Definition: Expr.h:4085
Lvalue-to-rvalue conversion (C++ 4.1)
Definition: Overload.h:62
List initialization failed at some point.
Perform a conversion adding _Atomic to a type.
void AddListInitializationStep(QualType T)
Add a list-initialization step.
Definition: SemaInit.cpp:3128
SourceLocation getDotLoc() const
Definition: Expr.h:4102
CanQualType OverloadTy
Definition: ASTContext.h:832
void ExpandDesignator(const ASTContext &C, unsigned Idx, const Designator *First, const Designator *Last)
Replaces the designator at index Idx with the series of designators in [First, Last).
Definition: Expr.cpp:4013
Perform a qualification conversion, producing an lvalue.
void AddLValueToRValueStep(QualType Ty)
Add a new step that performs a load of the given type.
Definition: SemaInit.cpp:3108
ExprResult MaybeBindToTemporary(Expr *E)
Kind
Expr * getArrayRangeEnd(const Designator &D) const
Definition: Expr.cpp:4004
SequenceKind
Describes the kind of initialization sequence computed.
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
unsigned getNumParams() const
Definition: Decl.cpp:2651
Reference initialization from an initializer list.
QualType getElementType() const
Definition: Type.h:2077
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
Definition: DeclBase.cpp:1493
static bool shouldBindAsTemporary(const InitializedEntity &Entity)
Whether we should bind a created object as a temporary when initializing the given entity...
Definition: SemaInit.cpp:5143
SourceLocation getLocation() const
Retrieve the location at which initialization is occurring.
SourceLocation getCaptureLoc() const
Determine the location of the capture when initializing field from a captured variable in a lambda...
bool isValid() const
Return true if this is a valid SourceLocation object.
Expr * getArrayRangeStart() const
Definition: Designator.h:94
FieldDecl * getField() const
Definition: Expr.h:4089
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
ASTContext & getASTContext() const
Definition: Sema.h:1026
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Definition: Expr.h:1158
void setReferenced(bool R=true)
Definition: DeclBase.h:532
VectorKind getVectorKind() const
Definition: Type.h:2732
StringInitFailureKind
Definition: SemaInit.cpp:47
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
OverloadingResult
Definition: Overload.h:40
static InitializedEntity InitializeElement(ASTContext &Context, unsigned Index, const InitializedEntity &Parent)
Create the initialization entity for an array element.
QualType withConst() const
Definition: Type.h:736
static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e, bool isAddressOf, bool &isWeakAccess)
Determines whether this expression is an acceptable ICR source.
Definition: SemaInit.cpp:4611
bool isExplicitCast() const
Determine whether this initialization is an explicit cast.
const Designator & getDesignator(unsigned Idx) const
Definition: Designator.h:194
void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit)
Adds a conversion function template specialization candidate to the overload set, using template argu...
const InitializedEntity * getParent() const
Retrieve the parent of the entity being initialized, when the initialization itself is occurring with...
Initialization of some unused destination type with an initializer list.
The entity being initialized is the result of a function call.
SourceLocation getLBracketLoc() const
Definition: Expr.h:4112
Objective-C ARC writeback conversion.
Definition: Overload.h:84
The entity being implicitly initialized back to the formal result type.
SourceLocation getRBracketLoc() const
Definition: Designator.h:112
The entity being initialized is the initializer for a compound literal.
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2003
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
void AddExtraneousCopyToTemporary(QualType T)
Add a new step that makes an extraneous copy of the input to a temporary of the same class type...
Definition: SemaInit.cpp:3061
CanQualType VoidTy
Definition: ASTContext.h:817
Expr * updateInit(const ASTContext &C, unsigned Init, Expr *expr)
Updates the initializer at index Init with the new expression expr, and returns the old expression at...
Definition: Expr.cpp:1913
Describes the kind of initialization being performed, along with location information for tokens rela...
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
Definition: SemaExpr.cpp:7062
The entity being initialized is an element of an array.
const Type * getBaseElementTypeUnsafe() const
Definition: Type.h:5520
bool isCStyleOrFunctionalCast() const
Determine whether this initialization is a C-style cast.
static ExprResult PerformConstructorInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, const InitializationSequence::Step &Step, bool &ConstructorInitRequiresZeroInit, bool IsListInitialization, bool IsStdInitListInitialization, SourceLocation LBraceLoc, SourceLocation RBraceLoc)
Definition: SemaInit.cpp:5538
static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc, QualType T)
Definition: SemaInit.cpp:6763
bool isRValue() const
Definition: Expr.h:355
bool isRValue() const
Definition: Expr.h:251
Expr ** getInits()
Retrieve the set of initializers.
Definition: Expr.h:3792
Overloading for initialization by constructor failed.
QualType getToType(unsigned Idx) const
Definition: Overload.h:214
static bool ResolveOverloadedFunctionForReferenceBinding(Sema &S, Expr *Initializer, QualType &SourceType, QualType &UnqualifiedSourceType, QualType UnqualifiedTargetType, InitializationSequence &Sequence)
Definition: SemaInit.cpp:3541
SourceLocation getBegin() const
bool isTypeDependent() const
Definition: Expr.h:166
An optional copy of a temporary object to another temporary object, which is permitted (but not requi...
static bool TryInitializerListConstruction(Sema &S, InitListExpr *List, QualType DestType, InitializationSequence &Sequence)
When initializing from init list via constructor, handle initialization of an object of type std::ini...
Definition: SemaInit.cpp:3318
lookup_result lookup(DeclarationName Name) const
Definition: DeclBase.cpp:1339
bool isVectorType() const
Definition: Type.h:5298
void AddAtomicConversionStep(QualType Ty)
Add a new step that performs conversion from non-atomic to atomic type.
Definition: SemaInit.cpp:3101
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2275
void AddPassByIndirectCopyRestoreStep(QualType T, bool shouldCopy)
Add a step to pass an object by indirect copy-restore.
Definition: SemaInit.cpp:3195
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1949
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5086
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:3840
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:645
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
Definition: Expr.h:436
static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT, Sema &S)
Definition: SemaInit.cpp:149
enum SequenceKind getKind() const
Determine the kind of initialization sequence computed.
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:261
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:68
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.cpp:193
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
getSpecialMember - get the special member enum for a method.
Definition: SemaDecl.cpp:2509
Pass an object by indirect copy-and-restore.
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, CXXConversionDecl *Method, bool HadMultipleCandidates)
Represents a C11 generic selection.
Definition: Expr.h:4446
void SetFailed(FailureKind Failure)
Note that this initialization sequence failed.
bool isCStyleCast() const
Determine whether this is a C-style cast.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
QualType getType() const
Definition: Expr.h:125
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
Definition: SemaInit.cpp:7629
Array must be initialized with an initializer list or a string literal.
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
static const Type * getElementType(const Expr *BaseExpr)
void setIncompleteTypeFailure(QualType IncompleteType)
Note that this initialization sequence failed due to an incomplete type.
A single step in the initialization sequence.
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type. ...
Definition: Type.cpp:1845
Array must be initialized with an initializer list or a wide string literal.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
Definition: Expr.cpp:1184
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1639
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
Definition: Sema.cpp:340
Too many initializers provided for a reference.
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type...
Definition: Expr.cpp:2633
static bool hasCompatibleArrayTypes(ASTContext &Context, const ArrayType *Dest, const ArrayType *Source)
Determine whether we have compatible array types for the purposes of GNU by-copy array initialization...
Definition: SemaInit.cpp:4696
bool isXValue() const
Definition: Expr.h:352
Perform a load from a glvalue, producing an rvalue.
static void checkIndirectCopyRestoreSource(Sema &S, Expr *src)
Definition: SemaInit.cpp:4678
bool isInvalidDecl() const
Definition: DeclBase.h:498
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
static bool InitializedEntityOutlivesFullExpression(const InitializedEntity &Entity)
Definition: SemaInit.cpp:5670
* Step
Definition: OpenMPClause.h:304
std::string getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const
Get a string to suggest for zero-initialization of a type.
bool isAtStartOfImmediateMacroExpansion(SourceLocation Loc, SourceLocation *MacroBegin=nullptr) const
Returns true if the given MacroID location points at the beginning of the immediate macro expansion...
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:104
Array-to-pointer conversion (C++ 4.2)
Definition: Overload.h:63
std::pair< SourceLocation, SourceLocation > getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
chain_iterator chain_end() const
Definition: Decl.h:2512
static void TryConstructorInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType DestType, InitializationSequence &Sequence, bool IsListInit=false, bool IsInitListCopy=false)
Attempt initialization by constructor (C++ [dcl.init]), which enumerates the constructors of the init...
Definition: SemaInit.cpp:3425
static bool IsWideCharCompatible(QualType T, ASTContext &Context)
Check whether T is compatible with a wide character type (wchar_t, char16_t or char32_t).
Definition: SemaInit.cpp:37
bool isUsed(bool CheckUsedAttr=true) const
Whether this declaration was used, meaning that a definition is required.
Definition: DeclBase.cpp:305
std::string getAsString(ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:545
StringKind getKind() const
Definition: Expr.h:1561
Requests that only viable candidates be shown.
Definition: Overload.h:53
bool usesGNUSyntax() const
Determines whether this designated initializer used the deprecated GNU syntax for designated initiali...
Definition: Expr.h:4221
DeclaratorDecl * VariableOrMember
When Kind == EK_Variable, or EK_Member, the VarDecl or FieldDecl, respectively.
bool isSamplerT() const
Definition: Type.h:5371
unsigned getNumArgs() const
Definition: Expr.h:2205
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1855
static ExprResult CopyObject(Sema &S, QualType T, const InitializedEntity &Entity, ExprResult CurInit, bool IsExtraneousCopy)
Make a (potentially elidable) temporary copy of the object provided by the given initializer by calli...
Definition: SemaInit.cpp:5302
bool isLValueReferenceType() const
Definition: Type.h:5244
Overloading due to reference initialization failed.
Expr * getArrayIndex() const
Definition: Designator.h:89
unsigned getNumArgs() const
Definition: ExprCXX.h:1198
bool isParameterKind() const
void setInitializedFieldInUnion(FieldDecl *FD)
Definition: Expr.h:3864
DeclClass * getCorrectionDeclAs() const
Expr * IgnoreParenImpCasts() LLVM_READONLY
Definition: Expr.cpp:2526
bool isRValueReferenceType() const
Definition: Type.h:5247
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase)
Create the initialization entity for a base class subobject.
Definition: SemaInit.cpp:2784
QualType getNonReferenceType() const
Definition: Type.h:5182
static bool isRValueRef(QualType ParamType)
Definition: Consumed.cpp:180
bool isObjCObjectType() const
Definition: Type.h:5307
const CXXBaseSpecifier * getBaseSpecifier() const
Retrieve the base specifier.
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition: Type.h:803
void setAllToTypes(QualType T)
Definition: Overload.h:205
static bool TryOCLZeroEventInitialization(Sema &S, InitializationSequence &Sequence, QualType DestType, Expr *Initializer)
Definition: SemaInit.cpp:4779
SourceManager & getSourceManager() const
Definition: Sema.h:1024
const T * getAs() const
Definition: Type.h:5555
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:3987
QualType getCanonicalType() const
Definition: Type.h:5055
Array must be initialized with an initializer list.
bool isConvertingConstructor(bool AllowExplicit) const
Definition: DeclCXX.cpp:1838
static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity, Expr *op)
Definition: SemaInit.cpp:6802
bool isParameterConsumed() const
Determine whether this initialization consumes the parameter.
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
SourceLocation getFieldLoc() const
Definition: Designator.h:84
[ARC] Produces a retainable object pointer so that it may be consumed, e.g. by being passed to a cons...
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1266
bool isFunctionType() const
Definition: Type.h:5229
Converts from T to _Atomic(T).
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1201
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
DeclContext * getRedeclContext()
Definition: DeclBase.cpp:1466
CXXConstructorDecl * getConstructor() const
Definition: ExprCXX.h:1137
LValueClassification
Definition: Expr.h:255
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1505
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, Expr *ArgExpr, DeclAccessPair FoundDecl)
bool isTrivial() const
Definition: Decl.h:1800
static bool isInvalid(SourceLocation Loc, bool *Invalid)
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:78
void AddDerivedToBaseCastStep(QualType BaseType, ExprValueKind Category)
Add a new step in the initialization that performs a derived-to- base cast.
Definition: SemaInit.cpp:3041
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, unsigned ConstructKind, SourceRange ParenRange)
Represents a base class of a C++ class.
Definition: DeclCXX.h:157
const CXXConstructorDecl * getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.cpp:1876
static bool TryOCLSamplerInitialization(Sema &S, InitializationSequence &Sequence, QualType DestType, Expr *Initializer)
Definition: SemaInit.cpp:4759
QualType getType() const
Retrieve type being initialized.
static OverloadingResult ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc, MultiExprArg Args, OverloadCandidateSet &CandidateSet, DeclContext::lookup_result Ctors, OverloadCandidateSet::iterator &Best, bool CopyInitializing, bool AllowExplicit, bool OnlyListConstructors, bool IsListInit)
Definition: SemaInit.cpp:3347
static SourceLocation getInitializationLoc(const InitializedEntity &Entity, Expr *Initializer)
Get the location at which initialization diagnostics should appear.
Definition: SemaInit.cpp:5249
bool isDefaultConstructor() const
Definition: DeclCXX.cpp:1777
An implicit conversion.
Definition: Sema.h:8024
bool AllowExplicit() const
Retrieve whether this initialization allows the use of explicit constructors.
Reading or writing from this object requires a barrier call.
Definition: Type.h:144
void AddUserConversionStep(FunctionDecl *Function, DeclAccessPair FoundDecl, QualType T, bool HadMultipleCandidates)
Add a new step invoking a conversion function, which is either a constructor or a conversion function...
Definition: SemaInit.cpp:3069
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
bool Failed() const
Determine whether the initialization sequence is invalid.
static void TryStringLiteralInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, InitializationSequence &Sequence)
Attempt character array initialization from a string literal (C++ [dcl.init.string], C99 6.7.8).
Definition: SemaInit.cpp:4304
Describes the sequence of initializations required to initialize a given object or reference with a s...
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=false)
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5096
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
Definition: Expr.h:3850
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
Compatible - the types are compatible according to the standard.
Definition: Sema.h:8142
Perform initialization via a constructor, taking arguments from a single InitListExpr.
static ExprValueKind convertQualifiersAndValueKindIfNecessary(Sema &S, InitializationSequence &Sequence, Expr *Initializer, QualType cv1T1, Qualifiers T1Quals, Qualifiers T2Quals, bool IsLValueRef)
Definition: SemaInit.cpp:4029
bool isObjCObjectPointerType() const
Definition: Type.h:5304
QualType getEncodedType() const
Definition: ExprObjC.h:377
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
Expr * getArrayRangeEnd() const
Definition: Designator.h:98
CanQualType Char16Ty
Definition: ASTContext.h:823
The entity being initialized is the field that captures a variable in a lambda.
void setSequenceKind(enum SequenceKind SK)
Set the kind of sequence computed.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:307
static void TryValueInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitializationSequence &Sequence, InitListExpr *InitList=nullptr)
Attempt value initialization (C++ [dcl.init]p7).
Definition: SemaInit.cpp:4313
A dependent initialization, which could not be type-checked due to the presence of dependent types or...
bool isEventT() const
Definition: Type.h:5375
InitializationSequence(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, bool TopLevelOfInitList=false)
Try to perform initialization of the given entity, creating a record of the steps required to perform...
Definition: SemaInit.cpp:4792
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorType::VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
bool isArrayType() const
Definition: Type.h:5271
bool isImplicitValueInit() const
Determine whether this initialization is an implicit value-initialization, e.g., as occurs during agg...
unsigned allocateManglingNumber() const
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best, bool UserDefinedConversion=false)
Find the best viable function on this overload set, if it exists.
Defines the clang::TargetInfo interface.
static OverloadingResult TryRefInitWithConversionFunction(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, bool AllowRValues, InitializationSequence &Sequence)
Try a reference initialization that involves calling a conversion function.
Definition: SemaInit.cpp:3801
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1290
Designator * getDesignator(unsigned Idx)
Definition: Expr.h:4205
void setInit(Expr *init)
Definition: Expr.h:4229
ExprResult ExprError()
Definition: Ownership.h:267
DeclarationName getName() const
Retrieve the name of the entity being initialized.
Definition: SemaInit.cpp:2798
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
Definition: Expr.cpp:2719
void reserveInits(const ASTContext &C, unsigned NumInits)
Reserve space for some number of initializers.
Definition: Expr.cpp:1904
static bool isReferenceBinding(const InitializationSequence::Step &s)
Definition: SemaInit.cpp:5506
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type...
bool isIncompleteArrayType() const
Definition: Type.h:5277
static Sema::AssignmentAction getAssignmentAction(const InitializedEntity &Entity, bool Diagnose=false)
Definition: SemaInit.cpp:5097
A reference to a declared variable, function, enum, etc. [C99 6.5.1p2].
Definition: Expr.h:899
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:404
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
CXXConstructorDecl * LookupDefaultConstructor(CXXRecordDecl *Class)
Look up the default constructor for the given class.
QualType getElementType() const
Definition: Type.h:2434
The initialization is being done by a delegating constructor.
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
void AddQualificationConversionStep(QualType Ty, ExprValueKind Category)
Add a new step that performs a qualification conversion to the given type.
Definition: SemaInit.cpp:3082
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool OdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
Definition: SemaExpr.cpp:12179
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5091
SourceManager & SourceMgr
Definition: Sema.h:298
void clear()
Clear out all of the candidates.
bool hasDefaultConstructor() const
Determine whether this class has any default constructors.
Definition: DeclCXX.h:818
ImplicitConversionKind First
Definition: Overload.h:133
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3794
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:3858
No viable function found.
Definition: Overload.h:42
bool isConstructorInitialization() const
Determine whether this initialization is direct call to a constructor.
Definition: SemaInit.cpp:3023
A failed initialization sequence. The failure kind tells what happened.
Array initialization (from an array rvalue). This is a GNU C extension.
AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair FoundDecl)
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:99
Default-initialization of a 'const' object.
void AddConversionSequenceStep(const ImplicitConversionSequence &ICS, QualType T, bool TopLevelOfInitList=false)
Add a new step that applies an implicit conversion sequence.
Definition: SemaInit.cpp:3117
size_t size() const
Definition: Overload.h:747
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:372
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl< Expr * > &ConvertedArgs, bool AllowExplicit=false, bool IsListInitialization=false)
Given a constructor and the set of arguments provided for the constructor, convert the arguments and ...
ASTContext & Context
Definition: Sema.h:295
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, std::unique_ptr< CorrectionCandidateCallback > CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
void dump() const
Dump a representation of this initialization sequence to standard error, for debugging purposes...
Definition: SemaInit.cpp:7517
unsigned getElementIndex() const
If this is an array, vector, or complex number element, get the element's index.
Automatic storage duration (most local variables).
Definition: Specifiers.h:240
bool isSignedIntegerType() const
Definition: Type.cpp:1683
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5075
static void DiagnoseNarrowingInInitList(Sema &S, const ImplicitConversionSequence &ICS, QualType PreNarrowingType, QualType EntityType, const Expr *PostInit)
Definition: SemaInit.cpp:7521
bool isNull() const
isNull - Return true if this QualType doesn't point to a type yet.
Definition: Type.h:633
Describes an entity that is being initialized.
NamespaceDecl * getStdNamespace() const
unsigned getNumDesignators() const
Definition: Designator.h:193
AssignmentAction
Definition: Sema.h:2111
SourceLocation getFieldLoc() const
Definition: Expr.h:4107
static void CheckCXX98CompatAccessibleCopy(Sema &S, const InitializedEntity &Entity, Expr *CurInitExpr)
Check whether elidable copy construction for binding a reference to a temporary would have succeeded ...
Definition: SemaInit.cpp:5437
Direct list-initialization.
Array initialization from a parenthesized initializer list. This is a GNU C++ extension.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
static void MaybeProduceObjCObject(Sema &S, InitializationSequence &Sequence, const InitializedEntity &Entity)
Definition: SemaInit.cpp:3280
Declaration of a template function.
Definition: DeclTemplate.h:821
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4352
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
static void TryReferenceListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitListExpr *InitList, InitializationSequence &Sequence)
Attempt list initialization of a reference.
Definition: SemaInit.cpp:3585
static bool maybeRecoverWithZeroInitialization(Sema &S, InitializationSequence &Sequence, const InitializedEntity &Entity)
Tries to add a zero initializer. Returns true if that worked.
Definition: SemaInit.cpp:3260
bool hasLocalStorage() const
Definition: Decl.h:887
Expr * IgnoreParens() LLVM_READONLY
Definition: Expr.cpp:2408
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5043
bool hasInClassInitializer() const
Definition: Decl.h:2377
bool isPointerType() const
Definition: Type.h:5232
SourceRange getSourceRange() const LLVM_READONLY
Definition: Expr.h:4145
static bool isExplicitTemporary(const InitializedEntity &Entity, const InitializationKind &Kind, unsigned NumArgs)
Definition: SemaInit.cpp:5513