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