clang  5.0.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 
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/DeclObjC.h"
16 #include "clang/AST/ExprCXX.h"
17 #include "clang/AST/ExprObjC.h"
18 #include "clang/AST/TypeLoc.h"
19 #include "clang/Basic/TargetInfo.h"
20 #include "clang/Sema/Designator.h"
22 #include "clang/Sema/Lookup.h"
24 #include "llvm/ADT/APInt.h"
25 #include "llvm/ADT/SmallString.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/raw_ostream.h"
28 
29 using namespace clang;
30 
31 //===----------------------------------------------------------------------===//
32 // Sema Initialization Checking
33 //===----------------------------------------------------------------------===//
34 
35 /// \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 namespace {
208 
209 /// @brief Semantic checking for initializer lists.
210 ///
211 /// The InitListChecker class contains a set of routines that each
212 /// handle the initialization of a certain kind of entity, e.g.,
213 /// arrays, vectors, struct/union types, scalars, etc. The
214 /// InitListChecker itself performs a recursive walk of the subobject
215 /// structure of the type to be initialized, while stepping through
216 /// the initializer list one element at a time. The IList and Index
217 /// parameters to each of the Check* routines contain the active
218 /// (syntactic) initializer list and the index into that initializer
219 /// list that represents the current initializer. Each routine is
220 /// responsible for moving that Index forward as it consumes elements.
221 ///
222 /// Each Check* routine also has a StructuredList/StructuredIndex
223 /// arguments, which contains the current "structured" (semantic)
224 /// initializer list and the index into that initializer list where we
225 /// are copying initializers as we map them over to the semantic
226 /// list. Once we have completed our recursive walk of the subobject
227 /// structure, we will have constructed a full semantic initializer
228 /// list.
229 ///
230 /// C99 designators cause changes in the initializer list traversal,
231 /// because they make the initialization "jump" into a specific
232 /// subobject and then continue the initialization from that
233 /// point. CheckDesignatedInitializer() recursively steps into the
234 /// designated subobject and manages backing out the recursion to
235 /// initialize the subobjects after the one designated.
236 class InitListChecker {
237  Sema &SemaRef;
238  bool hadError;
239  bool VerifyOnly; // no diagnostics, no structure building
240  bool TreatUnavailableAsInvalid; // Used only in VerifyOnly mode.
241  llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic;
242  InitListExpr *FullyStructuredList;
243 
244  void CheckImplicitInitList(const InitializedEntity &Entity,
245  InitListExpr *ParentIList, QualType T,
246  unsigned &Index, InitListExpr *StructuredList,
247  unsigned &StructuredIndex);
248  void CheckExplicitInitList(const InitializedEntity &Entity,
249  InitListExpr *IList, QualType &T,
250  InitListExpr *StructuredList,
251  bool TopLevelObject = false);
252  void CheckListElementTypes(const InitializedEntity &Entity,
253  InitListExpr *IList, QualType &DeclType,
254  bool SubobjectIsDesignatorContext,
255  unsigned &Index,
256  InitListExpr *StructuredList,
257  unsigned &StructuredIndex,
258  bool TopLevelObject = false);
259  void CheckSubElementType(const InitializedEntity &Entity,
260  InitListExpr *IList, QualType ElemType,
261  unsigned &Index,
262  InitListExpr *StructuredList,
263  unsigned &StructuredIndex);
264  void CheckComplexType(const InitializedEntity &Entity,
265  InitListExpr *IList, QualType DeclType,
266  unsigned &Index,
267  InitListExpr *StructuredList,
268  unsigned &StructuredIndex);
269  void CheckScalarType(const InitializedEntity &Entity,
270  InitListExpr *IList, QualType DeclType,
271  unsigned &Index,
272  InitListExpr *StructuredList,
273  unsigned &StructuredIndex);
274  void CheckReferenceType(const InitializedEntity &Entity,
275  InitListExpr *IList, QualType DeclType,
276  unsigned &Index,
277  InitListExpr *StructuredList,
278  unsigned &StructuredIndex);
279  void CheckVectorType(const InitializedEntity &Entity,
280  InitListExpr *IList, QualType DeclType, unsigned &Index,
281  InitListExpr *StructuredList,
282  unsigned &StructuredIndex);
283  void CheckStructUnionTypes(const InitializedEntity &Entity,
284  InitListExpr *IList, QualType DeclType,
287  bool SubobjectIsDesignatorContext, unsigned &Index,
288  InitListExpr *StructuredList,
289  unsigned &StructuredIndex,
290  bool TopLevelObject = false);
291  void CheckArrayType(const InitializedEntity &Entity,
292  InitListExpr *IList, QualType &DeclType,
293  llvm::APSInt elementIndex,
294  bool SubobjectIsDesignatorContext, unsigned &Index,
295  InitListExpr *StructuredList,
296  unsigned &StructuredIndex);
297  bool CheckDesignatedInitializer(const InitializedEntity &Entity,
298  InitListExpr *IList, DesignatedInitExpr *DIE,
299  unsigned DesigIdx,
300  QualType &CurrentObjectType,
301  RecordDecl::field_iterator *NextField,
302  llvm::APSInt *NextElementIndex,
303  unsigned &Index,
304  InitListExpr *StructuredList,
305  unsigned &StructuredIndex,
306  bool FinishSubobjectInit,
307  bool TopLevelObject);
308  InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
309  QualType CurrentObjectType,
310  InitListExpr *StructuredList,
311  unsigned StructuredIndex,
312  SourceRange InitRange,
313  bool IsFullyOverwritten = false);
314  void UpdateStructuredListElement(InitListExpr *StructuredList,
315  unsigned &StructuredIndex,
316  Expr *expr);
317  int numArrayElements(QualType DeclType);
318  int numStructUnionElements(QualType DeclType);
319 
320  static ExprResult PerformEmptyInit(Sema &SemaRef,
321  SourceLocation Loc,
322  const InitializedEntity &Entity,
323  bool VerifyOnly,
324  bool TreatUnavailableAsInvalid);
325 
326  // Explanation on the "FillWithNoInit" mode:
327  //
328  // Assume we have the following definitions (Case#1):
329  // struct P { char x[6][6]; } xp = { .x[1] = "bar" };
330  // struct PP { struct P lp; } l = { .lp = xp, .lp.x[1][2] = 'f' };
331  //
332  // l.lp.x[1][0..1] should not be filled with implicit initializers because the
333  // "base" initializer "xp" will provide values for them; l.lp.x[1] will be "baf".
334  //
335  // But if we have (Case#2):
336  // struct PP l = { .lp = xp, .lp.x[1] = { [2] = 'f' } };
337  //
338  // l.lp.x[1][0..1] are implicitly initialized and do not use values from the
339  // "base" initializer; l.lp.x[1] will be "\0\0f\0\0\0".
340  //
341  // To distinguish Case#1 from Case#2, and also to avoid leaving many "holes"
342  // in the InitListExpr, the "holes" in Case#1 are filled not with empty
343  // initializers but with special "NoInitExpr" place holders, which tells the
344  // CodeGen not to generate any initializers for these parts.
345  void FillInEmptyInitForBase(unsigned Init, const CXXBaseSpecifier &Base,
346  const InitializedEntity &ParentEntity,
347  InitListExpr *ILE, bool &RequiresSecondPass,
348  bool FillWithNoInit);
349  void FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
350  const InitializedEntity &ParentEntity,
351  InitListExpr *ILE, bool &RequiresSecondPass,
352  bool FillWithNoInit = false);
353  void FillInEmptyInitializations(const InitializedEntity &Entity,
354  InitListExpr *ILE, bool &RequiresSecondPass,
355  bool FillWithNoInit = false);
356  bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
357  Expr *InitExpr, FieldDecl *Field,
358  bool TopLevelObject);
359  void CheckEmptyInitializable(const InitializedEntity &Entity,
360  SourceLocation Loc);
361 
362 public:
363  InitListChecker(Sema &S, const InitializedEntity &Entity,
364  InitListExpr *IL, QualType &T, bool VerifyOnly,
365  bool TreatUnavailableAsInvalid);
366  bool HadError() { return hadError; }
367 
368  // @brief Retrieves the fully-structured initializer list used for
369  // semantic analysis and code generation.
370  InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
371 };
372 
373 } // end anonymous namespace
374 
375 ExprResult InitListChecker::PerformEmptyInit(Sema &SemaRef,
376  SourceLocation Loc,
377  const InitializedEntity &Entity,
378  bool VerifyOnly,
379  bool TreatUnavailableAsInvalid) {
381  true);
382  MultiExprArg SubInit;
383  Expr *InitExpr;
384  InitListExpr DummyInitList(SemaRef.Context, Loc, None, Loc);
385 
386  // C++ [dcl.init.aggr]p7:
387  // If there are fewer initializer-clauses in the list than there are
388  // members in the aggregate, then each member not explicitly initialized
389  // ...
390  bool EmptyInitList = SemaRef.getLangOpts().CPlusPlus11 &&
392  if (EmptyInitList) {
393  // C++1y / DR1070:
394  // shall be initialized [...] from an empty initializer list.
395  //
396  // We apply the resolution of this DR to C++11 but not C++98, since C++98
397  // does not have useful semantics for initialization from an init list.
398  // We treat this as copy-initialization, because aggregate initialization
399  // always performs copy-initialization on its elements.
400  //
401  // Only do this if we're initializing a class type, to avoid filling in
402  // the initializer list where possible.
403  InitExpr = VerifyOnly ? &DummyInitList : new (SemaRef.Context)
404  InitListExpr(SemaRef.Context, Loc, None, Loc);
405  InitExpr->setType(SemaRef.Context.VoidTy);
406  SubInit = InitExpr;
407  Kind = InitializationKind::CreateCopy(Loc, Loc);
408  } else {
409  // C++03:
410  // shall be value-initialized.
411  }
412 
413  InitializationSequence InitSeq(SemaRef, Entity, Kind, SubInit);
414  // libstdc++4.6 marks the vector default constructor as explicit in
415  // _GLIBCXX_DEBUG mode, so recover using the C++03 logic in that case.
416  // stlport does so too. Look for std::__debug for libstdc++, and for
417  // std:: for stlport. This is effectively a compiler-side implementation of
418  // LWG2193.
419  if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
423  InitSeq.getFailedCandidateSet()
424  .BestViableFunction(SemaRef, Kind.getLocation(), Best);
425  (void)O;
426  assert(O == OR_Success && "Inconsistent overload resolution");
427  CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
428  CXXRecordDecl *R = CtorDecl->getParent();
429 
430  if (CtorDecl->getMinRequiredArguments() == 0 &&
431  CtorDecl->isExplicit() && R->getDeclName() &&
432  SemaRef.SourceMgr.isInSystemHeader(CtorDecl->getLocation())) {
433  bool IsInStd = false;
434  for (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(R->getDeclContext());
435  ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
436  if (SemaRef.getStdNamespace()->InEnclosingNamespaceSetOf(ND))
437  IsInStd = true;
438  }
439 
440  if (IsInStd && llvm::StringSwitch<bool>(R->getName())
441  .Cases("basic_string", "deque", "forward_list", true)
442  .Cases("list", "map", "multimap", "multiset", true)
443  .Cases("priority_queue", "queue", "set", "stack", true)
444  .Cases("unordered_map", "unordered_set", "vector", true)
445  .Default(false)) {
446  InitSeq.InitializeFrom(
447  SemaRef, Entity,
448  InitializationKind::CreateValue(Loc, Loc, Loc, true),
449  MultiExprArg(), /*TopLevelOfInitList=*/false,
450  TreatUnavailableAsInvalid);
451  // Emit a warning for this. System header warnings aren't shown
452  // by default, but people working on system headers should see it.
453  if (!VerifyOnly) {
454  SemaRef.Diag(CtorDecl->getLocation(),
455  diag::warn_invalid_initializer_from_system_header);
456  if (Entity.getKind() == InitializedEntity::EK_Member)
457  SemaRef.Diag(Entity.getDecl()->getLocation(),
458  diag::note_used_in_initialization_here);
459  else if (Entity.getKind() == InitializedEntity::EK_ArrayElement)
460  SemaRef.Diag(Loc, diag::note_used_in_initialization_here);
461  }
462  }
463  }
464  }
465  if (!InitSeq) {
466  if (!VerifyOnly) {
467  InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
468  if (Entity.getKind() == InitializedEntity::EK_Member)
469  SemaRef.Diag(Entity.getDecl()->getLocation(),
470  diag::note_in_omitted_aggregate_initializer)
471  << /*field*/1 << Entity.getDecl();
472  else if (Entity.getKind() == InitializedEntity::EK_ArrayElement) {
473  bool IsTrailingArrayNewMember =
474  Entity.getParent() &&
476  SemaRef.Diag(Loc, diag::note_in_omitted_aggregate_initializer)
477  << (IsTrailingArrayNewMember ? 2 : /*array element*/0)
478  << Entity.getElementIndex();
479  }
480  }
481  return ExprError();
482  }
483 
484  return VerifyOnly ? ExprResult(static_cast<Expr *>(nullptr))
485  : InitSeq.Perform(SemaRef, Entity, Kind, SubInit);
486 }
487 
488 void InitListChecker::CheckEmptyInitializable(const InitializedEntity &Entity,
489  SourceLocation Loc) {
490  assert(VerifyOnly &&
491  "CheckEmptyInitializable is only inteded for verification mode.");
492  if (PerformEmptyInit(SemaRef, Loc, Entity, /*VerifyOnly*/true,
493  TreatUnavailableAsInvalid).isInvalid())
494  hadError = true;
495 }
496 
497 void InitListChecker::FillInEmptyInitForBase(
498  unsigned Init, const CXXBaseSpecifier &Base,
499  const InitializedEntity &ParentEntity, InitListExpr *ILE,
500  bool &RequiresSecondPass, bool FillWithNoInit) {
501  assert(Init < ILE->getNumInits() && "should have been expanded");
502 
504  SemaRef.Context, &Base, false, &ParentEntity);
505 
506  if (!ILE->getInit(Init)) {
507  ExprResult BaseInit =
508  FillWithNoInit ? new (SemaRef.Context) NoInitExpr(Base.getType())
509  : PerformEmptyInit(SemaRef, ILE->getLocEnd(), BaseEntity,
510  /*VerifyOnly*/ false,
511  TreatUnavailableAsInvalid);
512  if (BaseInit.isInvalid()) {
513  hadError = true;
514  return;
515  }
516 
517  ILE->setInit(Init, BaseInit.getAs<Expr>());
518  } else if (InitListExpr *InnerILE =
519  dyn_cast<InitListExpr>(ILE->getInit(Init))) {
520  FillInEmptyInitializations(BaseEntity, InnerILE,
521  RequiresSecondPass, FillWithNoInit);
522  } else if (DesignatedInitUpdateExpr *InnerDIUE =
523  dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init))) {
524  FillInEmptyInitializations(BaseEntity, InnerDIUE->getUpdater(),
525  RequiresSecondPass, /*FillWithNoInit =*/true);
526  }
527 }
528 
529 void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
530  const InitializedEntity &ParentEntity,
531  InitListExpr *ILE,
532  bool &RequiresSecondPass,
533  bool FillWithNoInit) {
534  SourceLocation Loc = ILE->getLocEnd();
535  unsigned NumInits = ILE->getNumInits();
536  InitializedEntity MemberEntity
537  = InitializedEntity::InitializeMember(Field, &ParentEntity);
538 
539  if (const RecordType *RType = ILE->getType()->getAs<RecordType>())
540  if (!RType->getDecl()->isUnion())
541  assert(Init < NumInits && "This ILE should have been expanded");
542 
543  if (Init >= NumInits || !ILE->getInit(Init)) {
544  if (FillWithNoInit) {
545  Expr *Filler = new (SemaRef.Context) NoInitExpr(Field->getType());
546  if (Init < NumInits)
547  ILE->setInit(Init, Filler);
548  else
549  ILE->updateInit(SemaRef.Context, Init, Filler);
550  return;
551  }
552  // C++1y [dcl.init.aggr]p7:
553  // If there are fewer initializer-clauses in the list than there are
554  // members in the aggregate, then each member not explicitly initialized
555  // shall be initialized from its brace-or-equal-initializer [...]
556  if (Field->hasInClassInitializer()) {
557  ExprResult DIE = SemaRef.BuildCXXDefaultInitExpr(Loc, Field);
558  if (DIE.isInvalid()) {
559  hadError = true;
560  return;
561  }
562  if (Init < NumInits)
563  ILE->setInit(Init, DIE.get());
564  else {
565  ILE->updateInit(SemaRef.Context, Init, DIE.get());
566  RequiresSecondPass = true;
567  }
568  return;
569  }
570 
571  if (Field->getType()->isReferenceType()) {
572  // C++ [dcl.init.aggr]p9:
573  // If an incomplete or empty initializer-list leaves a
574  // member of reference type uninitialized, the program is
575  // ill-formed.
576  SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
577  << Field->getType()
578  << ILE->getSyntacticForm()->getSourceRange();
579  SemaRef.Diag(Field->getLocation(),
580  diag::note_uninit_reference_member);
581  hadError = true;
582  return;
583  }
584 
585  ExprResult MemberInit = PerformEmptyInit(SemaRef, Loc, MemberEntity,
586  /*VerifyOnly*/false,
587  TreatUnavailableAsInvalid);
588  if (MemberInit.isInvalid()) {
589  hadError = true;
590  return;
591  }
592 
593  if (hadError) {
594  // Do nothing
595  } else if (Init < NumInits) {
596  ILE->setInit(Init, MemberInit.getAs<Expr>());
597  } else if (!isa<ImplicitValueInitExpr>(MemberInit.get())) {
598  // Empty initialization requires a constructor call, so
599  // extend the initializer list to include the constructor
600  // call and make a note that we'll need to take another pass
601  // through the initializer list.
602  ILE->updateInit(SemaRef.Context, Init, MemberInit.getAs<Expr>());
603  RequiresSecondPass = true;
604  }
605  } else if (InitListExpr *InnerILE
606  = dyn_cast<InitListExpr>(ILE->getInit(Init)))
607  FillInEmptyInitializations(MemberEntity, InnerILE,
608  RequiresSecondPass, FillWithNoInit);
609  else if (DesignatedInitUpdateExpr *InnerDIUE
610  = dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init)))
611  FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
612  RequiresSecondPass, /*FillWithNoInit =*/ true);
613 }
614 
615 /// Recursively replaces NULL values within the given initializer list
616 /// with expressions that perform value-initialization of the
617 /// appropriate type.
618 void
619 InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity,
620  InitListExpr *ILE,
621  bool &RequiresSecondPass,
622  bool FillWithNoInit) {
623  assert((ILE->getType() != SemaRef.Context.VoidTy) &&
624  "Should not have void type");
625 
626  // A transparent ILE is not performing aggregate initialization and should
627  // not be filled in.
628  if (ILE->isTransparent())
629  return;
630 
631  if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
632  const RecordDecl *RDecl = RType->getDecl();
633  if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())
634  FillInEmptyInitForField(0, ILE->getInitializedFieldInUnion(),
635  Entity, ILE, RequiresSecondPass, FillWithNoInit);
636  else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
637  cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
638  for (auto *Field : RDecl->fields()) {
639  if (Field->hasInClassInitializer()) {
640  FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass,
641  FillWithNoInit);
642  break;
643  }
644  }
645  } else {
646  // The fields beyond ILE->getNumInits() are default initialized, so in
647  // order to leave them uninitialized, the ILE is expanded and the extra
648  // fields are then filled with NoInitExpr.
649  unsigned NumElems = numStructUnionElements(ILE->getType());
650  if (RDecl->hasFlexibleArrayMember())
651  ++NumElems;
652  if (ILE->getNumInits() < NumElems)
653  ILE->resizeInits(SemaRef.Context, NumElems);
654 
655  unsigned Init = 0;
656 
657  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RDecl)) {
658  for (auto &Base : CXXRD->bases()) {
659  if (hadError)
660  return;
661 
662  FillInEmptyInitForBase(Init, Base, Entity, ILE, RequiresSecondPass,
663  FillWithNoInit);
664  ++Init;
665  }
666  }
667 
668  for (auto *Field : RDecl->fields()) {
669  if (Field->isUnnamedBitfield())
670  continue;
671 
672  if (hadError)
673  return;
674 
675  FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass,
676  FillWithNoInit);
677  if (hadError)
678  return;
679 
680  ++Init;
681 
682  // Only look at the first initialization of a union.
683  if (RDecl->isUnion())
684  break;
685  }
686  }
687 
688  return;
689  }
690 
691  QualType ElementType;
692 
693  InitializedEntity ElementEntity = Entity;
694  unsigned NumInits = ILE->getNumInits();
695  unsigned NumElements = NumInits;
696  if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
697  ElementType = AType->getElementType();
698  if (const auto *CAType = dyn_cast<ConstantArrayType>(AType))
699  NumElements = CAType->getSize().getZExtValue();
700  // For an array new with an unknown bound, ask for one additional element
701  // in order to populate the array filler.
702  if (Entity.isVariableLengthArrayNew())
703  ++NumElements;
704  ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
705  0, Entity);
706  } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
707  ElementType = VType->getElementType();
708  NumElements = VType->getNumElements();
709  ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
710  0, Entity);
711  } else
712  ElementType = ILE->getType();
713 
714  for (unsigned Init = 0; Init != NumElements; ++Init) {
715  if (hadError)
716  return;
717 
718  if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
719  ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
720  ElementEntity.setElementIndex(Init);
721 
722  Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr);
723  if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
724  ILE->setInit(Init, ILE->getArrayFiller());
725  else if (!InitExpr && !ILE->hasArrayFiller()) {
726  Expr *Filler = nullptr;
727 
728  if (FillWithNoInit)
729  Filler = new (SemaRef.Context) NoInitExpr(ElementType);
730  else {
731  ExprResult ElementInit = PerformEmptyInit(SemaRef, ILE->getLocEnd(),
732  ElementEntity,
733  /*VerifyOnly*/false,
734  TreatUnavailableAsInvalid);
735  if (ElementInit.isInvalid()) {
736  hadError = true;
737  return;
738  }
739 
740  Filler = ElementInit.getAs<Expr>();
741  }
742 
743  if (hadError) {
744  // Do nothing
745  } else if (Init < NumInits) {
746  // For arrays, just set the expression used for value-initialization
747  // of the "holes" in the array.
748  if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
749  ILE->setArrayFiller(Filler);
750  else
751  ILE->setInit(Init, Filler);
752  } else {
753  // For arrays, just set the expression used for value-initialization
754  // of the rest of elements and exit.
755  if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
756  ILE->setArrayFiller(Filler);
757  return;
758  }
759 
760  if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {
761  // Empty initialization requires a constructor call, so
762  // extend the initializer list to include the constructor
763  // call and make a note that we'll need to take another pass
764  // through the initializer list.
765  ILE->updateInit(SemaRef.Context, Init, Filler);
766  RequiresSecondPass = true;
767  }
768  }
769  } else if (InitListExpr *InnerILE
770  = dyn_cast_or_null<InitListExpr>(InitExpr))
771  FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
772  FillWithNoInit);
773  else if (DesignatedInitUpdateExpr *InnerDIUE
774  = dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr))
775  FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
776  RequiresSecondPass, /*FillWithNoInit =*/ true);
777  }
778 }
779 
780 InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
781  InitListExpr *IL, QualType &T,
782  bool VerifyOnly,
783  bool TreatUnavailableAsInvalid)
784  : SemaRef(S), VerifyOnly(VerifyOnly),
785  TreatUnavailableAsInvalid(TreatUnavailableAsInvalid) {
786  // FIXME: Check that IL isn't already the semantic form of some other
787  // InitListExpr. If it is, we'd create a broken AST.
788 
789  hadError = false;
790 
791  FullyStructuredList =
792  getStructuredSubobjectInit(IL, 0, T, nullptr, 0, IL->getSourceRange());
793  CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
794  /*TopLevelObject=*/true);
795 
796  if (!hadError && !VerifyOnly) {
797  bool RequiresSecondPass = false;
798  FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass);
799  if (RequiresSecondPass && !hadError)
800  FillInEmptyInitializations(Entity, FullyStructuredList,
801  RequiresSecondPass);
802  }
803 }
804 
805 int InitListChecker::numArrayElements(QualType DeclType) {
806  // FIXME: use a proper constant
807  int maxElements = 0x7FFFFFFF;
808  if (const ConstantArrayType *CAT =
809  SemaRef.Context.getAsConstantArrayType(DeclType)) {
810  maxElements = static_cast<int>(CAT->getSize().getZExtValue());
811  }
812  return maxElements;
813 }
814 
815 int InitListChecker::numStructUnionElements(QualType DeclType) {
816  RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
817  int InitializableMembers = 0;
818  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(structDecl))
819  InitializableMembers += CXXRD->getNumBases();
820  for (const auto *Field : structDecl->fields())
821  if (!Field->isUnnamedBitfield())
822  ++InitializableMembers;
823 
824  if (structDecl->isUnion())
825  return std::min(InitializableMembers, 1);
826  return InitializableMembers - structDecl->hasFlexibleArrayMember();
827 }
828 
829 /// Check whether the range of the initializer \p ParentIList from element
830 /// \p Index onwards can be used to initialize an object of type \p T. Update
831 /// \p Index to indicate how many elements of the list were consumed.
832 ///
833 /// This also fills in \p StructuredList, from element \p StructuredIndex
834 /// onwards, with the fully-braced, desugared form of the initialization.
835 void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
836  InitListExpr *ParentIList,
837  QualType T, unsigned &Index,
838  InitListExpr *StructuredList,
839  unsigned &StructuredIndex) {
840  int maxElements = 0;
841 
842  if (T->isArrayType())
843  maxElements = numArrayElements(T);
844  else if (T->isRecordType())
845  maxElements = numStructUnionElements(T);
846  else if (T->isVectorType())
847  maxElements = T->getAs<VectorType>()->getNumElements();
848  else
849  llvm_unreachable("CheckImplicitInitList(): Illegal type");
850 
851  if (maxElements == 0) {
852  if (!VerifyOnly)
853  SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
854  diag::err_implicit_empty_initializer);
855  ++Index;
856  hadError = true;
857  return;
858  }
859 
860  // Build a structured initializer list corresponding to this subobject.
861  InitListExpr *StructuredSubobjectInitList
862  = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
863  StructuredIndex,
864  SourceRange(ParentIList->getInit(Index)->getLocStart(),
865  ParentIList->getSourceRange().getEnd()));
866  unsigned StructuredSubobjectInitIndex = 0;
867 
868  // Check the element types and build the structural subobject.
869  unsigned StartIndex = Index;
870  CheckListElementTypes(Entity, ParentIList, T,
871  /*SubobjectIsDesignatorContext=*/false, Index,
872  StructuredSubobjectInitList,
873  StructuredSubobjectInitIndex);
874 
875  if (!VerifyOnly) {
876  StructuredSubobjectInitList->setType(T);
877 
878  unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
879  // Update the structured sub-object initializer so that it's ending
880  // range corresponds with the end of the last initializer it used.
881  if (EndIndex < ParentIList->getNumInits() &&
882  ParentIList->getInit(EndIndex)) {
883  SourceLocation EndLoc
884  = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
885  StructuredSubobjectInitList->setRBraceLoc(EndLoc);
886  }
887 
888  // Complain about missing braces.
889  if (T->isArrayType() || T->isRecordType()) {
890  SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
891  diag::warn_missing_braces)
892  << StructuredSubobjectInitList->getSourceRange()
893  << FixItHint::CreateInsertion(
894  StructuredSubobjectInitList->getLocStart(), "{")
895  << FixItHint::CreateInsertion(
896  SemaRef.getLocForEndOfToken(
897  StructuredSubobjectInitList->getLocEnd()),
898  "}");
899  }
900  }
901 }
902 
903 /// Warn that \p Entity was of scalar type and was initialized by a
904 /// single-element braced initializer list.
905 static void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity,
906  SourceRange Braces) {
907  // Don't warn during template instantiation. If the initialization was
908  // non-dependent, we warned during the initial parse; otherwise, the
909  // type might not be scalar in some uses of the template.
910  if (S.inTemplateInstantiation())
911  return;
912 
913  unsigned DiagID = 0;
914 
915  switch (Entity.getKind()) {
916  case InitializedEntity::EK_VectorElement:
917  case InitializedEntity::EK_ComplexElement:
918  case InitializedEntity::EK_ArrayElement:
919  case InitializedEntity::EK_Parameter:
920  case InitializedEntity::EK_Parameter_CF_Audited:
921  case InitializedEntity::EK_Result:
922  // Extra braces here are suspicious.
923  DiagID = diag::warn_braces_around_scalar_init;
924  break;
925 
926  case InitializedEntity::EK_Member:
927  // Warn on aggregate initialization but not on ctor init list or
928  // default member initializer.
929  if (Entity.getParent())
930  DiagID = diag::warn_braces_around_scalar_init;
931  break;
932 
933  case InitializedEntity::EK_Variable:
934  case InitializedEntity::EK_LambdaCapture:
935  // No warning, might be direct-list-initialization.
936  // FIXME: Should we warn for copy-list-initialization in these cases?
937  break;
938 
939  case InitializedEntity::EK_New:
940  case InitializedEntity::EK_Temporary:
941  case InitializedEntity::EK_CompoundLiteralInit:
942  // No warning, braces are part of the syntax of the underlying construct.
943  break;
944 
945  case InitializedEntity::EK_RelatedResult:
946  // No warning, we already warned when initializing the result.
947  break;
948 
949  case InitializedEntity::EK_Exception:
950  case InitializedEntity::EK_Base:
951  case InitializedEntity::EK_Delegating:
952  case InitializedEntity::EK_BlockElement:
953  case InitializedEntity::EK_LambdaToBlockConversionBlockElement:
954  case InitializedEntity::EK_Binding:
955  llvm_unreachable("unexpected braced scalar init");
956  }
957 
958  if (DiagID) {
959  S.Diag(Braces.getBegin(), DiagID)
960  << Braces
961  << FixItHint::CreateRemoval(Braces.getBegin())
962  << FixItHint::CreateRemoval(Braces.getEnd());
963  }
964 }
965 
966 /// Check whether the initializer \p IList (that was written with explicit
967 /// braces) can be used to initialize an object of type \p T.
968 ///
969 /// This also fills in \p StructuredList with the fully-braced, desugared
970 /// form of the initialization.
971 void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
972  InitListExpr *IList, QualType &T,
973  InitListExpr *StructuredList,
974  bool TopLevelObject) {
975  if (!VerifyOnly) {
976  SyntacticToSemantic[IList] = StructuredList;
977  StructuredList->setSyntacticForm(IList);
978  }
979 
980  unsigned Index = 0, StructuredIndex = 0;
981  CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
982  Index, StructuredList, StructuredIndex, TopLevelObject);
983  if (!VerifyOnly) {
984  QualType ExprTy = T;
985  if (!ExprTy->isArrayType())
986  ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context);
987  IList->setType(ExprTy);
988  StructuredList->setType(ExprTy);
989  }
990  if (hadError)
991  return;
992 
993  if (Index < IList->getNumInits()) {
994  // We have leftover initializers
995  if (VerifyOnly) {
996  if (SemaRef.getLangOpts().CPlusPlus ||
997  (SemaRef.getLangOpts().OpenCL &&
998  IList->getType()->isVectorType())) {
999  hadError = true;
1000  }
1001  return;
1002  }
1003 
1004  if (StructuredIndex == 1 &&
1005  IsStringInit(StructuredList->getInit(0), T, SemaRef.Context) ==
1006  SIF_None) {
1007  unsigned DK = diag::ext_excess_initializers_in_char_array_initializer;
1008  if (SemaRef.getLangOpts().CPlusPlus) {
1009  DK = diag::err_excess_initializers_in_char_array_initializer;
1010  hadError = true;
1011  }
1012  // Special-case
1013  SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
1014  << IList->getInit(Index)->getSourceRange();
1015  } else if (!T->isIncompleteType()) {
1016  // Don't complain for incomplete types, since we'll get an error
1017  // elsewhere
1018  QualType CurrentObjectType = StructuredList->getType();
1019  int initKind =
1020  CurrentObjectType->isArrayType()? 0 :
1021  CurrentObjectType->isVectorType()? 1 :
1022  CurrentObjectType->isScalarType()? 2 :
1023  CurrentObjectType->isUnionType()? 3 :
1024  4;
1025 
1026  unsigned DK = diag::ext_excess_initializers;
1027  if (SemaRef.getLangOpts().CPlusPlus) {
1028  DK = diag::err_excess_initializers;
1029  hadError = true;
1030  }
1031  if (SemaRef.getLangOpts().OpenCL && initKind == 1) {
1032  DK = diag::err_excess_initializers;
1033  hadError = true;
1034  }
1035 
1036  SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
1037  << initKind << IList->getInit(Index)->getSourceRange();
1038  }
1039  }
1040 
1041  if (!VerifyOnly && T->isScalarType() &&
1042  IList->getNumInits() == 1 && !isa<InitListExpr>(IList->getInit(0)))
1043  warnBracedScalarInit(SemaRef, Entity, IList->getSourceRange());
1044 }
1045 
1046 void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
1047  InitListExpr *IList,
1048  QualType &DeclType,
1049  bool SubobjectIsDesignatorContext,
1050  unsigned &Index,
1051  InitListExpr *StructuredList,
1052  unsigned &StructuredIndex,
1053  bool TopLevelObject) {
1054  if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
1055  // Explicitly braced initializer for complex type can be real+imaginary
1056  // parts.
1057  CheckComplexType(Entity, IList, DeclType, Index,
1058  StructuredList, StructuredIndex);
1059  } else if (DeclType->isScalarType()) {
1060  CheckScalarType(Entity, IList, DeclType, Index,
1061  StructuredList, StructuredIndex);
1062  } else if (DeclType->isVectorType()) {
1063  CheckVectorType(Entity, IList, DeclType, Index,
1064  StructuredList, StructuredIndex);
1065  } else if (DeclType->isRecordType()) {
1066  assert(DeclType->isAggregateType() &&
1067  "non-aggregate records should be handed in CheckSubElementType");
1068  RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1069  auto Bases =
1072  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1073  Bases = CXXRD->bases();
1074  CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(),
1075  SubobjectIsDesignatorContext, Index, StructuredList,
1076  StructuredIndex, TopLevelObject);
1077  } else if (DeclType->isArrayType()) {
1078  llvm::APSInt Zero(
1079  SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
1080  false);
1081  CheckArrayType(Entity, IList, DeclType, Zero,
1082  SubobjectIsDesignatorContext, Index,
1083  StructuredList, StructuredIndex);
1084  } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
1085  // This type is invalid, issue a diagnostic.
1086  ++Index;
1087  if (!VerifyOnly)
1088  SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
1089  << DeclType;
1090  hadError = true;
1091  } else if (DeclType->isReferenceType()) {
1092  CheckReferenceType(Entity, IList, DeclType, Index,
1093  StructuredList, StructuredIndex);
1094  } else if (DeclType->isObjCObjectType()) {
1095  if (!VerifyOnly)
1096  SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
1097  << DeclType;
1098  hadError = true;
1099  } else {
1100  if (!VerifyOnly)
1101  SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
1102  << DeclType;
1103  hadError = true;
1104  }
1105 }
1106 
1107 void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
1108  InitListExpr *IList,
1109  QualType ElemType,
1110  unsigned &Index,
1111  InitListExpr *StructuredList,
1112  unsigned &StructuredIndex) {
1113  Expr *expr = IList->getInit(Index);
1114 
1115  if (ElemType->isReferenceType())
1116  return CheckReferenceType(Entity, IList, ElemType, Index,
1117  StructuredList, StructuredIndex);
1118 
1119  if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
1120  if (SubInitList->getNumInits() == 1 &&
1121  IsStringInit(SubInitList->getInit(0), ElemType, SemaRef.Context) ==
1122  SIF_None) {
1123  expr = SubInitList->getInit(0);
1124  } else if (!SemaRef.getLangOpts().CPlusPlus) {
1125  InitListExpr *InnerStructuredList
1126  = getStructuredSubobjectInit(IList, Index, ElemType,
1127  StructuredList, StructuredIndex,
1128  SubInitList->getSourceRange(), true);
1129  CheckExplicitInitList(Entity, SubInitList, ElemType,
1130  InnerStructuredList);
1131 
1132  if (!hadError && !VerifyOnly) {
1133  bool RequiresSecondPass = false;
1134  FillInEmptyInitializations(Entity, InnerStructuredList,
1135  RequiresSecondPass);
1136  if (RequiresSecondPass && !hadError)
1137  FillInEmptyInitializations(Entity, InnerStructuredList,
1138  RequiresSecondPass);
1139  }
1140  ++StructuredIndex;
1141  ++Index;
1142  return;
1143  }
1144  // C++ initialization is handled later.
1145  } else if (isa<ImplicitValueInitExpr>(expr)) {
1146  // This happens during template instantiation when we see an InitListExpr
1147  // that we've already checked once.
1148  assert(SemaRef.Context.hasSameType(expr->getType(), ElemType) &&
1149  "found implicit initialization for the wrong type");
1150  if (!VerifyOnly)
1151  UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1152  ++Index;
1153  return;
1154  }
1155 
1156  if (SemaRef.getLangOpts().CPlusPlus) {
1157  // C++ [dcl.init.aggr]p2:
1158  // Each member is copy-initialized from the corresponding
1159  // initializer-clause.
1160 
1161  // FIXME: Better EqualLoc?
1162  InitializationKind Kind =
1163  InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
1164  InitializationSequence Seq(SemaRef, Entity, Kind, expr,
1165  /*TopLevelOfInitList*/ true);
1166 
1167  // C++14 [dcl.init.aggr]p13:
1168  // If the assignment-expression can initialize a member, the member is
1169  // initialized. Otherwise [...] brace elision is assumed
1170  //
1171  // Brace elision is never performed if the element is not an
1172  // assignment-expression.
1173  if (Seq || isa<InitListExpr>(expr)) {
1174  if (!VerifyOnly) {
1175  ExprResult Result =
1176  Seq.Perform(SemaRef, Entity, Kind, expr);
1177  if (Result.isInvalid())
1178  hadError = true;
1179 
1180  UpdateStructuredListElement(StructuredList, StructuredIndex,
1181  Result.getAs<Expr>());
1182  } else if (!Seq)
1183  hadError = true;
1184  ++Index;
1185  return;
1186  }
1187 
1188  // Fall through for subaggregate initialization
1189  } else if (ElemType->isScalarType() || ElemType->isAtomicType()) {
1190  // FIXME: Need to handle atomic aggregate types with implicit init lists.
1191  return CheckScalarType(Entity, IList, ElemType, Index,
1192  StructuredList, StructuredIndex);
1193  } else if (const ArrayType *arrayType =
1194  SemaRef.Context.getAsArrayType(ElemType)) {
1195  // arrayType can be incomplete if we're initializing a flexible
1196  // array member. There's nothing we can do with the completed
1197  // type here, though.
1198 
1199  if (IsStringInit(expr, arrayType, SemaRef.Context) == SIF_None) {
1200  if (!VerifyOnly) {
1201  CheckStringInit(expr, ElemType, arrayType, SemaRef);
1202  UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1203  }
1204  ++Index;
1205  return;
1206  }
1207 
1208  // Fall through for subaggregate initialization.
1209 
1210  } else {
1211  assert((ElemType->isRecordType() || ElemType->isVectorType() ||
1212  ElemType->isOpenCLSpecificType()) && "Unexpected type");
1213 
1214  // C99 6.7.8p13:
1215  //
1216  // The initializer for a structure or union object that has
1217  // automatic storage duration shall be either an initializer
1218  // list as described below, or a single expression that has
1219  // compatible structure or union type. In the latter case, the
1220  // initial value of the object, including unnamed members, is
1221  // that of the expression.
1222  ExprResult ExprRes = expr;
1224  ElemType, ExprRes, !VerifyOnly) != Sema::Incompatible) {
1225  if (ExprRes.isInvalid())
1226  hadError = true;
1227  else {
1228  ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.get());
1229  if (ExprRes.isInvalid())
1230  hadError = true;
1231  }
1232  UpdateStructuredListElement(StructuredList, StructuredIndex,
1233  ExprRes.getAs<Expr>());
1234  ++Index;
1235  return;
1236  }
1237  ExprRes.get();
1238  // Fall through for subaggregate initialization
1239  }
1240 
1241  // C++ [dcl.init.aggr]p12:
1242  //
1243  // [...] Otherwise, if the member is itself a non-empty
1244  // subaggregate, brace elision is assumed and the initializer is
1245  // considered for the initialization of the first member of
1246  // the subaggregate.
1247  // OpenCL vector initializer is handled elsewhere.
1248  if ((!SemaRef.getLangOpts().OpenCL && ElemType->isVectorType()) ||
1249  ElemType->isAggregateType()) {
1250  CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
1251  StructuredIndex);
1252  ++StructuredIndex;
1253  } else {
1254  if (!VerifyOnly) {
1255  // We cannot initialize this element, so let
1256  // PerformCopyInitialization produce the appropriate diagnostic.
1257  SemaRef.PerformCopyInitialization(Entity, SourceLocation(), expr,
1258  /*TopLevelOfInitList=*/true);
1259  }
1260  hadError = true;
1261  ++Index;
1262  ++StructuredIndex;
1263  }
1264 }
1265 
1266 void InitListChecker::CheckComplexType(const InitializedEntity &Entity,
1267  InitListExpr *IList, QualType DeclType,
1268  unsigned &Index,
1269  InitListExpr *StructuredList,
1270  unsigned &StructuredIndex) {
1271  assert(Index == 0 && "Index in explicit init list must be zero");
1272 
1273  // As an extension, clang supports complex initializers, which initialize
1274  // a complex number component-wise. When an explicit initializer list for
1275  // a complex number contains two two initializers, this extension kicks in:
1276  // it exepcts the initializer list to contain two elements convertible to
1277  // the element type of the complex type. The first element initializes
1278  // the real part, and the second element intitializes the imaginary part.
1279 
1280  if (IList->getNumInits() != 2)
1281  return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1282  StructuredIndex);
1283 
1284  // This is an extension in C. (The builtin _Complex type does not exist
1285  // in the C++ standard.)
1286  if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly)
1287  SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init)
1288  << IList->getSourceRange();
1289 
1290  // Initialize the complex number.
1291  QualType elementType = DeclType->getAs<ComplexType>()->getElementType();
1292  InitializedEntity ElementEntity =
1293  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1294 
1295  for (unsigned i = 0; i < 2; ++i) {
1296  ElementEntity.setElementIndex(Index);
1297  CheckSubElementType(ElementEntity, IList, elementType, Index,
1298  StructuredList, StructuredIndex);
1299  }
1300 }
1301 
1302 void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
1303  InitListExpr *IList, QualType DeclType,
1304  unsigned &Index,
1305  InitListExpr *StructuredList,
1306  unsigned &StructuredIndex) {
1307  if (Index >= IList->getNumInits()) {
1308  if (!VerifyOnly)
1309  SemaRef.Diag(IList->getLocStart(),
1310  SemaRef.getLangOpts().CPlusPlus11 ?
1311  diag::warn_cxx98_compat_empty_scalar_initializer :
1312  diag::err_empty_scalar_initializer)
1313  << IList->getSourceRange();
1314  hadError = !SemaRef.getLangOpts().CPlusPlus11;
1315  ++Index;
1316  ++StructuredIndex;
1317  return;
1318  }
1319 
1320  Expr *expr = IList->getInit(Index);
1321  if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
1322  // FIXME: This is invalid, and accepting it causes overload resolution
1323  // to pick the wrong overload in some corner cases.
1324  if (!VerifyOnly)
1325  SemaRef.Diag(SubIList->getLocStart(),
1326  diag::ext_many_braces_around_scalar_init)
1327  << SubIList->getSourceRange();
1328 
1329  CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1330  StructuredIndex);
1331  return;
1332  } else if (isa<DesignatedInitExpr>(expr)) {
1333  if (!VerifyOnly)
1334  SemaRef.Diag(expr->getLocStart(),
1335  diag::err_designator_for_scalar_init)
1336  << DeclType << expr->getSourceRange();
1337  hadError = true;
1338  ++Index;
1339  ++StructuredIndex;
1340  return;
1341  }
1342 
1343  if (VerifyOnly) {
1344  if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1345  hadError = true;
1346  ++Index;
1347  return;
1348  }
1349 
1350  ExprResult Result =
1351  SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1352  /*TopLevelOfInitList=*/true);
1353 
1354  Expr *ResultExpr = nullptr;
1355 
1356  if (Result.isInvalid())
1357  hadError = true; // types weren't compatible.
1358  else {
1359  ResultExpr = Result.getAs<Expr>();
1360 
1361  if (ResultExpr != expr) {
1362  // The type was promoted, update initializer list.
1363  IList->setInit(Index, ResultExpr);
1364  }
1365  }
1366  if (hadError)
1367  ++StructuredIndex;
1368  else
1369  UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1370  ++Index;
1371 }
1372 
1373 void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
1374  InitListExpr *IList, QualType DeclType,
1375  unsigned &Index,
1376  InitListExpr *StructuredList,
1377  unsigned &StructuredIndex) {
1378  if (Index >= IList->getNumInits()) {
1379  // FIXME: It would be wonderful if we could point at the actual member. In
1380  // general, it would be useful to pass location information down the stack,
1381  // so that we know the location (or decl) of the "current object" being
1382  // initialized.
1383  if (!VerifyOnly)
1384  SemaRef.Diag(IList->getLocStart(),
1385  diag::err_init_reference_member_uninitialized)
1386  << DeclType
1387  << IList->getSourceRange();
1388  hadError = true;
1389  ++Index;
1390  ++StructuredIndex;
1391  return;
1392  }
1393 
1394  Expr *expr = IList->getInit(Index);
1395  if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) {
1396  if (!VerifyOnly)
1397  SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
1398  << DeclType << IList->getSourceRange();
1399  hadError = true;
1400  ++Index;
1401  ++StructuredIndex;
1402  return;
1403  }
1404 
1405  if (VerifyOnly) {
1406  if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1407  hadError = true;
1408  ++Index;
1409  return;
1410  }
1411 
1412  ExprResult Result =
1413  SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1414  /*TopLevelOfInitList=*/true);
1415 
1416  if (Result.isInvalid())
1417  hadError = true;
1418 
1419  expr = Result.getAs<Expr>();
1420  IList->setInit(Index, expr);
1421 
1422  if (hadError)
1423  ++StructuredIndex;
1424  else
1425  UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1426  ++Index;
1427 }
1428 
1429 void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
1430  InitListExpr *IList, QualType DeclType,
1431  unsigned &Index,
1432  InitListExpr *StructuredList,
1433  unsigned &StructuredIndex) {
1434  const VectorType *VT = DeclType->getAs<VectorType>();
1435  unsigned maxElements = VT->getNumElements();
1436  unsigned numEltsInit = 0;
1437  QualType elementType = VT->getElementType();
1438 
1439  if (Index >= IList->getNumInits()) {
1440  // Make sure the element type can be value-initialized.
1441  if (VerifyOnly)
1442  CheckEmptyInitializable(
1443  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity),
1444  IList->getLocEnd());
1445  return;
1446  }
1447 
1448  if (!SemaRef.getLangOpts().OpenCL) {
1449  // If the initializing element is a vector, try to copy-initialize
1450  // instead of breaking it apart (which is doomed to failure anyway).
1451  Expr *Init = IList->getInit(Index);
1452  if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
1453  if (VerifyOnly) {
1454  if (!SemaRef.CanPerformCopyInitialization(Entity, Init))
1455  hadError = true;
1456  ++Index;
1457  return;
1458  }
1459 
1460  ExprResult Result =
1461  SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(), Init,
1462  /*TopLevelOfInitList=*/true);
1463 
1464  Expr *ResultExpr = nullptr;
1465  if (Result.isInvalid())
1466  hadError = true; // types weren't compatible.
1467  else {
1468  ResultExpr = Result.getAs<Expr>();
1469 
1470  if (ResultExpr != Init) {
1471  // The type was promoted, update initializer list.
1472  IList->setInit(Index, ResultExpr);
1473  }
1474  }
1475  if (hadError)
1476  ++StructuredIndex;
1477  else
1478  UpdateStructuredListElement(StructuredList, StructuredIndex,
1479  ResultExpr);
1480  ++Index;
1481  return;
1482  }
1483 
1484  InitializedEntity ElementEntity =
1485  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1486 
1487  for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1488  // Don't attempt to go past the end of the init list
1489  if (Index >= IList->getNumInits()) {
1490  if (VerifyOnly)
1491  CheckEmptyInitializable(ElementEntity, IList->getLocEnd());
1492  break;
1493  }
1494 
1495  ElementEntity.setElementIndex(Index);
1496  CheckSubElementType(ElementEntity, IList, elementType, Index,
1497  StructuredList, StructuredIndex);
1498  }
1499 
1500  if (VerifyOnly)
1501  return;
1502 
1503  bool isBigEndian = SemaRef.Context.getTargetInfo().isBigEndian();
1504  const VectorType *T = Entity.getType()->getAs<VectorType>();
1505  if (isBigEndian && (T->getVectorKind() == VectorType::NeonVector ||
1506  T->getVectorKind() == VectorType::NeonPolyVector)) {
1507  // The ability to use vector initializer lists is a GNU vector extension
1508  // and is unrelated to the NEON intrinsics in arm_neon.h. On little
1509  // endian machines it works fine, however on big endian machines it
1510  // exhibits surprising behaviour:
1511  //
1512  // uint32x2_t x = {42, 64};
1513  // return vget_lane_u32(x, 0); // Will return 64.
1514  //
1515  // Because of this, explicitly call out that it is non-portable.
1516  //
1517  SemaRef.Diag(IList->getLocStart(),
1518  diag::warn_neon_vector_initializer_non_portable);
1519 
1520  const char *typeCode;
1521  unsigned typeSize = SemaRef.Context.getTypeSize(elementType);
1522 
1523  if (elementType->isFloatingType())
1524  typeCode = "f";
1525  else if (elementType->isSignedIntegerType())
1526  typeCode = "s";
1527  else if (elementType->isUnsignedIntegerType())
1528  typeCode = "u";
1529  else
1530  llvm_unreachable("Invalid element type!");
1531 
1532  SemaRef.Diag(IList->getLocStart(),
1533  SemaRef.Context.getTypeSize(VT) > 64 ?
1534  diag::note_neon_vector_initializer_non_portable_q :
1535  diag::note_neon_vector_initializer_non_portable)
1536  << typeCode << typeSize;
1537  }
1538 
1539  return;
1540  }
1541 
1542  InitializedEntity ElementEntity =
1543  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1544 
1545  // OpenCL initializers allows vectors to be constructed from vectors.
1546  for (unsigned i = 0; i < maxElements; ++i) {
1547  // Don't attempt to go past the end of the init list
1548  if (Index >= IList->getNumInits())
1549  break;
1550 
1551  ElementEntity.setElementIndex(Index);
1552 
1553  QualType IType = IList->getInit(Index)->getType();
1554  if (!IType->isVectorType()) {
1555  CheckSubElementType(ElementEntity, IList, elementType, Index,
1556  StructuredList, StructuredIndex);
1557  ++numEltsInit;
1558  } else {
1559  QualType VecType;
1560  const VectorType *IVT = IType->getAs<VectorType>();
1561  unsigned numIElts = IVT->getNumElements();
1562 
1563  if (IType->isExtVectorType())
1564  VecType = SemaRef.Context.getExtVectorType(elementType, numIElts);
1565  else
1566  VecType = SemaRef.Context.getVectorType(elementType, numIElts,
1567  IVT->getVectorKind());
1568  CheckSubElementType(ElementEntity, IList, VecType, Index,
1569  StructuredList, StructuredIndex);
1570  numEltsInit += numIElts;
1571  }
1572  }
1573 
1574  // OpenCL requires all elements to be initialized.
1575  if (numEltsInit != maxElements) {
1576  if (!VerifyOnly)
1577  SemaRef.Diag(IList->getLocStart(),
1578  diag::err_vector_incorrect_num_initializers)
1579  << (numEltsInit < maxElements) << maxElements << numEltsInit;
1580  hadError = true;
1581  }
1582 }
1583 
1584 void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
1585  InitListExpr *IList, QualType &DeclType,
1586  llvm::APSInt elementIndex,
1587  bool SubobjectIsDesignatorContext,
1588  unsigned &Index,
1589  InitListExpr *StructuredList,
1590  unsigned &StructuredIndex) {
1591  const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType);
1592 
1593  // Check for the special-case of initializing an array with a string.
1594  if (Index < IList->getNumInits()) {
1595  if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) ==
1596  SIF_None) {
1597  // We place the string literal directly into the resulting
1598  // initializer list. This is the only place where the structure
1599  // of the structured initializer list doesn't match exactly,
1600  // because doing so would involve allocating one character
1601  // constant for each string.
1602  if (!VerifyOnly) {
1603  CheckStringInit(IList->getInit(Index), DeclType, arrayType, SemaRef);
1604  UpdateStructuredListElement(StructuredList, StructuredIndex,
1605  IList->getInit(Index));
1606  StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
1607  }
1608  ++Index;
1609  return;
1610  }
1611  }
1612  if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
1613  // Check for VLAs; in standard C it would be possible to check this
1614  // earlier, but I don't know where clang accepts VLAs (gcc accepts
1615  // them in all sorts of strange places).
1616  if (!VerifyOnly)
1617  SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
1618  diag::err_variable_object_no_init)
1619  << VAT->getSizeExpr()->getSourceRange();
1620  hadError = true;
1621  ++Index;
1622  ++StructuredIndex;
1623  return;
1624  }
1625 
1626  // We might know the maximum number of elements in advance.
1627  llvm::APSInt maxElements(elementIndex.getBitWidth(),
1628  elementIndex.isUnsigned());
1629  bool maxElementsKnown = false;
1630  if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) {
1631  maxElements = CAT->getSize();
1632  elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
1633  elementIndex.setIsUnsigned(maxElements.isUnsigned());
1634  maxElementsKnown = true;
1635  }
1636 
1637  QualType elementType = arrayType->getElementType();
1638  while (Index < IList->getNumInits()) {
1639  Expr *Init = IList->getInit(Index);
1640  if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1641  // If we're not the subobject that matches up with the '{' for
1642  // the designator, we shouldn't be handling the
1643  // designator. Return immediately.
1644  if (!SubobjectIsDesignatorContext)
1645  return;
1646 
1647  // Handle this designated initializer. elementIndex will be
1648  // updated to be the next array element we'll initialize.
1649  if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1650  DeclType, nullptr, &elementIndex, Index,
1651  StructuredList, StructuredIndex, true,
1652  false)) {
1653  hadError = true;
1654  continue;
1655  }
1656 
1657  if (elementIndex.getBitWidth() > maxElements.getBitWidth())
1658  maxElements = maxElements.extend(elementIndex.getBitWidth());
1659  else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
1660  elementIndex = elementIndex.extend(maxElements.getBitWidth());
1661  elementIndex.setIsUnsigned(maxElements.isUnsigned());
1662 
1663  // If the array is of incomplete type, keep track of the number of
1664  // elements in the initializer.
1665  if (!maxElementsKnown && elementIndex > maxElements)
1666  maxElements = elementIndex;
1667 
1668  continue;
1669  }
1670 
1671  // If we know the maximum number of elements, and we've already
1672  // hit it, stop consuming elements in the initializer list.
1673  if (maxElementsKnown && elementIndex == maxElements)
1674  break;
1675 
1676  InitializedEntity ElementEntity =
1677  InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
1678  Entity);
1679  // Check this element.
1680  CheckSubElementType(ElementEntity, IList, elementType, Index,
1681  StructuredList, StructuredIndex);
1682  ++elementIndex;
1683 
1684  // If the array is of incomplete type, keep track of the number of
1685  // elements in the initializer.
1686  if (!maxElementsKnown && elementIndex > maxElements)
1687  maxElements = elementIndex;
1688  }
1689  if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) {
1690  // If this is an incomplete array type, the actual type needs to
1691  // be calculated here.
1692  llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
1693  if (maxElements == Zero && !Entity.isVariableLengthArrayNew()) {
1694  // Sizing an array implicitly to zero is not allowed by ISO C,
1695  // but is supported by GNU.
1696  SemaRef.Diag(IList->getLocStart(),
1697  diag::ext_typecheck_zero_array_size);
1698  }
1699 
1700  DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
1701  ArrayType::Normal, 0);
1702  }
1703  if (!hadError && VerifyOnly) {
1704  // If there are any members of the array that get value-initialized, check
1705  // that is possible. That happens if we know the bound and don't have
1706  // enough elements, or if we're performing an array new with an unknown
1707  // bound.
1708  // FIXME: This needs to detect holes left by designated initializers too.
1709  if ((maxElementsKnown && elementIndex < maxElements) ||
1710  Entity.isVariableLengthArrayNew())
1711  CheckEmptyInitializable(InitializedEntity::InitializeElement(
1712  SemaRef.Context, 0, Entity),
1713  IList->getLocEnd());
1714  }
1715 }
1716 
1717 bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity,
1718  Expr *InitExpr,
1719  FieldDecl *Field,
1720  bool TopLevelObject) {
1721  // Handle GNU flexible array initializers.
1722  unsigned FlexArrayDiag;
1723  if (isa<InitListExpr>(InitExpr) &&
1724  cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
1725  // Empty flexible array init always allowed as an extension
1726  FlexArrayDiag = diag::ext_flexible_array_init;
1727  } else if (SemaRef.getLangOpts().CPlusPlus) {
1728  // Disallow flexible array init in C++; it is not required for gcc
1729  // compatibility, and it needs work to IRGen correctly in general.
1730  FlexArrayDiag = diag::err_flexible_array_init;
1731  } else if (!TopLevelObject) {
1732  // Disallow flexible array init on non-top-level object
1733  FlexArrayDiag = diag::err_flexible_array_init;
1734  } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
1735  // Disallow flexible array init on anything which is not a variable.
1736  FlexArrayDiag = diag::err_flexible_array_init;
1737  } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) {
1738  // Disallow flexible array init on local variables.
1739  FlexArrayDiag = diag::err_flexible_array_init;
1740  } else {
1741  // Allow other cases.
1742  FlexArrayDiag = diag::ext_flexible_array_init;
1743  }
1744 
1745  if (!VerifyOnly) {
1746  SemaRef.Diag(InitExpr->getLocStart(),
1747  FlexArrayDiag)
1748  << InitExpr->getLocStart();
1749  SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1750  << Field;
1751  }
1752 
1753  return FlexArrayDiag != diag::ext_flexible_array_init;
1754 }
1755 
1756 void InitListChecker::CheckStructUnionTypes(
1757  const InitializedEntity &Entity, InitListExpr *IList, QualType DeclType,
1759  bool SubobjectIsDesignatorContext, unsigned &Index,
1760  InitListExpr *StructuredList, unsigned &StructuredIndex,
1761  bool TopLevelObject) {
1762  RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
1763 
1764  // If the record is invalid, some of it's members are invalid. To avoid
1765  // confusion, we forgo checking the intializer for the entire record.
1766  if (structDecl->isInvalidDecl()) {
1767  // Assume it was supposed to consume a single initializer.
1768  ++Index;
1769  hadError = true;
1770  return;
1771  }
1772 
1773  if (DeclType->isUnionType() && IList->getNumInits() == 0) {
1774  RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1775 
1776  // If there's a default initializer, use it.
1777  if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
1778  if (VerifyOnly)
1779  return;
1780  for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1781  Field != FieldEnd; ++Field) {
1782  if (Field->hasInClassInitializer()) {
1783  StructuredList->setInitializedFieldInUnion(*Field);
1784  // FIXME: Actually build a CXXDefaultInitExpr?
1785  return;
1786  }
1787  }
1788  }
1789 
1790  // Value-initialize the first member of the union that isn't an unnamed
1791  // bitfield.
1792  for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1793  Field != FieldEnd; ++Field) {
1794  if (!Field->isUnnamedBitfield()) {
1795  if (VerifyOnly)
1796  CheckEmptyInitializable(
1797  InitializedEntity::InitializeMember(*Field, &Entity),
1798  IList->getLocEnd());
1799  else
1800  StructuredList->setInitializedFieldInUnion(*Field);
1801  break;
1802  }
1803  }
1804  return;
1805  }
1806 
1807  bool InitializedSomething = false;
1808 
1809  // If we have any base classes, they are initialized prior to the fields.
1810  for (auto &Base : Bases) {
1811  Expr *Init = Index < IList->getNumInits() ? IList->getInit(Index) : nullptr;
1812  SourceLocation InitLoc = Init ? Init->getLocStart() : IList->getLocEnd();
1813 
1814  // Designated inits always initialize fields, so if we see one, all
1815  // remaining base classes have no explicit initializer.
1816  if (Init && isa<DesignatedInitExpr>(Init))
1817  Init = nullptr;
1818 
1819  InitializedEntity BaseEntity = InitializedEntity::InitializeBase(
1820  SemaRef.Context, &Base, false, &Entity);
1821  if (Init) {
1822  CheckSubElementType(BaseEntity, IList, Base.getType(), Index,
1823  StructuredList, StructuredIndex);
1824  InitializedSomething = true;
1825  } else if (VerifyOnly) {
1826  CheckEmptyInitializable(BaseEntity, InitLoc);
1827  }
1828  }
1829 
1830  // If structDecl is a forward declaration, this loop won't do
1831  // anything except look at designated initializers; That's okay,
1832  // because an error should get printed out elsewhere. It might be
1833  // worthwhile to skip over the rest of the initializer, though.
1834  RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1835  RecordDecl::field_iterator FieldEnd = RD->field_end();
1836  bool CheckForMissingFields = true;
1837  while (Index < IList->getNumInits()) {
1838  Expr *Init = IList->getInit(Index);
1839 
1840  if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1841  // If we're not the subobject that matches up with the '{' for
1842  // the designator, we shouldn't be handling the
1843  // designator. Return immediately.
1844  if (!SubobjectIsDesignatorContext)
1845  return;
1846 
1847  // Handle this designated initializer. Field will be updated to
1848  // the next field that we'll be initializing.
1849  if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1850  DeclType, &Field, nullptr, Index,
1851  StructuredList, StructuredIndex,
1852  true, TopLevelObject))
1853  hadError = true;
1854 
1855  InitializedSomething = true;
1856 
1857  // Disable check for missing fields when designators are used.
1858  // This matches gcc behaviour.
1859  CheckForMissingFields = false;
1860  continue;
1861  }
1862 
1863  if (Field == FieldEnd) {
1864  // We've run out of fields. We're done.
1865  break;
1866  }
1867 
1868  // We've already initialized a member of a union. We're done.
1869  if (InitializedSomething && DeclType->isUnionType())
1870  break;
1871 
1872  // If we've hit the flexible array member at the end, we're done.
1873  if (Field->getType()->isIncompleteArrayType())
1874  break;
1875 
1876  if (Field->isUnnamedBitfield()) {
1877  // Don't initialize unnamed bitfields, e.g. "int : 20;"
1878  ++Field;
1879  continue;
1880  }
1881 
1882  // Make sure we can use this declaration.
1883  bool InvalidUse;
1884  if (VerifyOnly)
1885  InvalidUse = !SemaRef.CanUseDecl(*Field, TreatUnavailableAsInvalid);
1886  else
1887  InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field,
1888  IList->getInit(Index)->getLocStart());
1889  if (InvalidUse) {
1890  ++Index;
1891  ++Field;
1892  hadError = true;
1893  continue;
1894  }
1895 
1896  InitializedEntity MemberEntity =
1897  InitializedEntity::InitializeMember(*Field, &Entity);
1898  CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1899  StructuredList, StructuredIndex);
1900  InitializedSomething = true;
1901 
1902  if (DeclType->isUnionType() && !VerifyOnly) {
1903  // Initialize the first field within the union.
1904  StructuredList->setInitializedFieldInUnion(*Field);
1905  }
1906 
1907  ++Field;
1908  }
1909 
1910  // Emit warnings for missing struct field initializers.
1911  if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
1912  Field != FieldEnd && !Field->getType()->isIncompleteArrayType() &&
1913  !DeclType->isUnionType()) {
1914  // It is possible we have one or more unnamed bitfields remaining.
1915  // Find first (if any) named field and emit warning.
1916  for (RecordDecl::field_iterator it = Field, end = RD->field_end();
1917  it != end; ++it) {
1918  if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) {
1919  SemaRef.Diag(IList->getSourceRange().getEnd(),
1920  diag::warn_missing_field_initializers) << *it;
1921  break;
1922  }
1923  }
1924  }
1925 
1926  // Check that any remaining fields can be value-initialized.
1927  if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() &&
1928  !Field->getType()->isIncompleteArrayType()) {
1929  // FIXME: Should check for holes left by designated initializers too.
1930  for (; Field != FieldEnd && !hadError; ++Field) {
1931  if (!Field->isUnnamedBitfield() && !Field->hasInClassInitializer())
1932  CheckEmptyInitializable(
1933  InitializedEntity::InitializeMember(*Field, &Entity),
1934  IList->getLocEnd());
1935  }
1936  }
1937 
1938  if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
1939  Index >= IList->getNumInits())
1940  return;
1941 
1942  if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field,
1943  TopLevelObject)) {
1944  hadError = true;
1945  ++Index;
1946  return;
1947  }
1948 
1949  InitializedEntity MemberEntity =
1950  InitializedEntity::InitializeMember(*Field, &Entity);
1951 
1952  if (isa<InitListExpr>(IList->getInit(Index)))
1953  CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1954  StructuredList, StructuredIndex);
1955  else
1956  CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
1957  StructuredList, StructuredIndex);
1958 }
1959 
1960 /// \brief Expand a field designator that refers to a member of an
1961 /// anonymous struct or union into a series of field designators that
1962 /// refers to the field within the appropriate subobject.
1963 ///
1965  DesignatedInitExpr *DIE,
1966  unsigned DesigIdx,
1967  IndirectFieldDecl *IndirectField) {
1969 
1970  // Build the replacement designators.
1971  SmallVector<Designator, 4> Replacements;
1972  for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
1973  PE = IndirectField->chain_end(); PI != PE; ++PI) {
1974  if (PI + 1 == PE)
1975  Replacements.push_back(Designator((IdentifierInfo *)nullptr,
1976  DIE->getDesignator(DesigIdx)->getDotLoc(),
1977  DIE->getDesignator(DesigIdx)->getFieldLoc()));
1978  else
1979  Replacements.push_back(Designator((IdentifierInfo *)nullptr,
1981  assert(isa<FieldDecl>(*PI));
1982  Replacements.back().setField(cast<FieldDecl>(*PI));
1983  }
1984 
1985  // Expand the current designator into the set of replacement
1986  // designators, so we have a full subobject path down to where the
1987  // member of the anonymous struct/union is actually stored.
1988  DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
1989  &Replacements[0] + Replacements.size());
1990 }
1991 
1993  DesignatedInitExpr *DIE) {
1994  unsigned NumIndexExprs = DIE->getNumSubExprs() - 1;
1995  SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
1996  for (unsigned I = 0; I < NumIndexExprs; ++I)
1997  IndexExprs[I] = DIE->getSubExpr(I + 1);
1998  return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators(),
1999  IndexExprs,
2000  DIE->getEqualOrColonLoc(),
2001  DIE->usesGNUSyntax(), DIE->getInit());
2002 }
2003 
2004 namespace {
2005 
2006 // Callback to only accept typo corrections that are for field members of
2007 // the given struct or union.
2008 class FieldInitializerValidatorCCC : public CorrectionCandidateCallback {
2009  public:
2010  explicit FieldInitializerValidatorCCC(RecordDecl *RD)
2011  : Record(RD) {}
2012 
2013  bool ValidateCandidate(const TypoCorrection &candidate) override {
2014  FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>();
2015  return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record);
2016  }
2017 
2018  private:
2019  RecordDecl *Record;
2020 };
2021 
2022 } // end anonymous namespace
2023 
2024 /// @brief Check the well-formedness of a C99 designated initializer.
2025 ///
2026 /// Determines whether the designated initializer @p DIE, which
2027 /// resides at the given @p Index within the initializer list @p
2028 /// IList, is well-formed for a current object of type @p DeclType
2029 /// (C99 6.7.8). The actual subobject that this designator refers to
2030 /// within the current subobject is returned in either
2031 /// @p NextField or @p NextElementIndex (whichever is appropriate).
2032 ///
2033 /// @param IList The initializer list in which this designated
2034 /// initializer occurs.
2035 ///
2036 /// @param DIE The designated initializer expression.
2037 ///
2038 /// @param DesigIdx The index of the current designator.
2039 ///
2040 /// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
2041 /// into which the designation in @p DIE should refer.
2042 ///
2043 /// @param NextField If non-NULL and the first designator in @p DIE is
2044 /// a field, this will be set to the field declaration corresponding
2045 /// to the field named by the designator.
2046 ///
2047 /// @param NextElementIndex If non-NULL and the first designator in @p
2048 /// DIE is an array designator or GNU array-range designator, this
2049 /// will be set to the last index initialized by this designator.
2050 ///
2051 /// @param Index Index into @p IList where the designated initializer
2052 /// @p DIE occurs.
2053 ///
2054 /// @param StructuredList The initializer list expression that
2055 /// describes all of the subobject initializers in the order they'll
2056 /// actually be initialized.
2057 ///
2058 /// @returns true if there was an error, false otherwise.
2059 bool
2060 InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
2061  InitListExpr *IList,
2062  DesignatedInitExpr *DIE,
2063  unsigned DesigIdx,
2064  QualType &CurrentObjectType,
2065  RecordDecl::field_iterator *NextField,
2066  llvm::APSInt *NextElementIndex,
2067  unsigned &Index,
2068  InitListExpr *StructuredList,
2069  unsigned &StructuredIndex,
2070  bool FinishSubobjectInit,
2071  bool TopLevelObject) {
2072  if (DesigIdx == DIE->size()) {
2073  // Check the actual initialization for the designated object type.
2074  bool prevHadError = hadError;
2075 
2076  // Temporarily remove the designator expression from the
2077  // initializer list that the child calls see, so that we don't try
2078  // to re-process the designator.
2079  unsigned OldIndex = Index;
2080  IList->setInit(OldIndex, DIE->getInit());
2081 
2082  CheckSubElementType(Entity, IList, CurrentObjectType, Index,
2083  StructuredList, StructuredIndex);
2084 
2085  // Restore the designated initializer expression in the syntactic
2086  // form of the initializer list.
2087  if (IList->getInit(OldIndex) != DIE->getInit())
2088  DIE->setInit(IList->getInit(OldIndex));
2089  IList->setInit(OldIndex, DIE);
2090 
2091  return hadError && !prevHadError;
2092  }
2093 
2094  DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
2095  bool IsFirstDesignator = (DesigIdx == 0);
2096  if (!VerifyOnly) {
2097  assert((IsFirstDesignator || StructuredList) &&
2098  "Need a non-designated initializer list to start from");
2099 
2100  // Determine the structural initializer list that corresponds to the
2101  // current subobject.
2102  if (IsFirstDesignator)
2103  StructuredList = SyntacticToSemantic.lookup(IList);
2104  else {
2105  Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2106  StructuredList->getInit(StructuredIndex) : nullptr;
2107  if (!ExistingInit && StructuredList->hasArrayFiller())
2108  ExistingInit = StructuredList->getArrayFiller();
2109 
2110  if (!ExistingInit)
2111  StructuredList =
2112  getStructuredSubobjectInit(IList, Index, CurrentObjectType,
2113  StructuredList, StructuredIndex,
2114  SourceRange(D->getLocStart(),
2115  DIE->getLocEnd()));
2116  else if (InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2117  StructuredList = Result;
2118  else {
2120  dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2121  StructuredList = E->getUpdater();
2122  else {
2123  DesignatedInitUpdateExpr *DIUE =
2124  new (SemaRef.Context) DesignatedInitUpdateExpr(SemaRef.Context,
2125  D->getLocStart(), ExistingInit,
2126  DIE->getLocEnd());
2127  StructuredList->updateInit(SemaRef.Context, StructuredIndex, DIUE);
2128  StructuredList = DIUE->getUpdater();
2129  }
2130 
2131  // We need to check on source range validity because the previous
2132  // initializer does not have to be an explicit initializer. e.g.,
2133  //
2134  // struct P { int a, b; };
2135  // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2136  //
2137  // There is an overwrite taking place because the first braced initializer
2138  // list "{ .a = 2 }" already provides value for .p.b (which is zero).
2139  if (ExistingInit->getSourceRange().isValid()) {
2140  // We are creating an initializer list that initializes the
2141  // subobjects of the current object, but there was already an
2142  // initialization that completely initialized the current
2143  // subobject, e.g., by a compound literal:
2144  //
2145  // struct X { int a, b; };
2146  // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2147  //
2148  // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2149  // designated initializer re-initializes the whole
2150  // subobject [0], overwriting previous initializers.
2151  SemaRef.Diag(D->getLocStart(),
2152  diag::warn_subobject_initializer_overrides)
2153  << SourceRange(D->getLocStart(), DIE->getLocEnd());
2154 
2155  SemaRef.Diag(ExistingInit->getLocStart(),
2156  diag::note_previous_initializer)
2157  << /*FIXME:has side effects=*/0
2158  << ExistingInit->getSourceRange();
2159  }
2160  }
2161  }
2162  assert(StructuredList && "Expected a structured initializer list");
2163  }
2164 
2165  if (D->isFieldDesignator()) {
2166  // C99 6.7.8p7:
2167  //
2168  // If a designator has the form
2169  //
2170  // . identifier
2171  //
2172  // then the current object (defined below) shall have
2173  // structure or union type and the identifier shall be the
2174  // name of a member of that type.
2175  const RecordType *RT = CurrentObjectType->getAs<RecordType>();
2176  if (!RT) {
2177  SourceLocation Loc = D->getDotLoc();
2178  if (Loc.isInvalid())
2179  Loc = D->getFieldLoc();
2180  if (!VerifyOnly)
2181  SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
2182  << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
2183  ++Index;
2184  return true;
2185  }
2186 
2187  FieldDecl *KnownField = D->getField();
2188  if (!KnownField) {
2189  IdentifierInfo *FieldName = D->getFieldName();
2190  DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
2191  for (NamedDecl *ND : Lookup) {
2192  if (auto *FD = dyn_cast<FieldDecl>(ND)) {
2193  KnownField = FD;
2194  break;
2195  }
2196  if (auto *IFD = dyn_cast<IndirectFieldDecl>(ND)) {
2197  // In verify mode, don't modify the original.
2198  if (VerifyOnly)
2199  DIE = CloneDesignatedInitExpr(SemaRef, DIE);
2200  ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IFD);
2201  D = DIE->getDesignator(DesigIdx);
2202  KnownField = cast<FieldDecl>(*IFD->chain_begin());
2203  break;
2204  }
2205  }
2206  if (!KnownField) {
2207  if (VerifyOnly) {
2208  ++Index;
2209  return true; // No typo correction when just trying this out.
2210  }
2211 
2212  // Name lookup found something, but it wasn't a field.
2213  if (!Lookup.empty()) {
2214  SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
2215  << FieldName;
2216  SemaRef.Diag(Lookup.front()->getLocation(),
2217  diag::note_field_designator_found);
2218  ++Index;
2219  return true;
2220  }
2221 
2222  // Name lookup didn't find anything.
2223  // Determine whether this was a typo for another field name.
2224  if (TypoCorrection Corrected = SemaRef.CorrectTypo(
2225  DeclarationNameInfo(FieldName, D->getFieldLoc()),
2226  Sema::LookupMemberName, /*Scope=*/nullptr, /*SS=*/nullptr,
2227  llvm::make_unique<FieldInitializerValidatorCCC>(RT->getDecl()),
2228  Sema::CTK_ErrorRecovery, RT->getDecl())) {
2229  SemaRef.diagnoseTypo(
2230  Corrected,
2231  SemaRef.PDiag(diag::err_field_designator_unknown_suggest)
2232  << FieldName << CurrentObjectType);
2233  KnownField = Corrected.getCorrectionDeclAs<FieldDecl>();
2234  hadError = true;
2235  } else {
2236  // Typo correction didn't find anything.
2237  SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
2238  << FieldName << CurrentObjectType;
2239  ++Index;
2240  return true;
2241  }
2242  }
2243  }
2244 
2245  unsigned FieldIndex = 0;
2246 
2247  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
2248  FieldIndex = CXXRD->getNumBases();
2249 
2250  for (auto *FI : RT->getDecl()->fields()) {
2251  if (FI->isUnnamedBitfield())
2252  continue;
2253  if (declaresSameEntity(KnownField, FI)) {
2254  KnownField = FI;
2255  break;
2256  }
2257  ++FieldIndex;
2258  }
2259 
2262 
2263  // All of the fields of a union are located at the same place in
2264  // the initializer list.
2265  if (RT->getDecl()->isUnion()) {
2266  FieldIndex = 0;
2267  if (!VerifyOnly) {
2268  FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2269  if (CurrentField && !declaresSameEntity(CurrentField, *Field)) {
2270  assert(StructuredList->getNumInits() == 1
2271  && "A union should never have more than one initializer!");
2272 
2273  Expr *ExistingInit = StructuredList->getInit(0);
2274  if (ExistingInit) {
2275  // We're about to throw away an initializer, emit warning.
2276  SemaRef.Diag(D->getFieldLoc(),
2277  diag::warn_initializer_overrides)
2278  << D->getSourceRange();
2279  SemaRef.Diag(ExistingInit->getLocStart(),
2280  diag::note_previous_initializer)
2281  << /*FIXME:has side effects=*/0
2282  << ExistingInit->getSourceRange();
2283  }
2284 
2285  // remove existing initializer
2286  StructuredList->resizeInits(SemaRef.Context, 0);
2287  StructuredList->setInitializedFieldInUnion(nullptr);
2288  }
2289 
2290  StructuredList->setInitializedFieldInUnion(*Field);
2291  }
2292  }
2293 
2294  // Make sure we can use this declaration.
2295  bool InvalidUse;
2296  if (VerifyOnly)
2297  InvalidUse = !SemaRef.CanUseDecl(*Field, TreatUnavailableAsInvalid);
2298  else
2299  InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
2300  if (InvalidUse) {
2301  ++Index;
2302  return true;
2303  }
2304 
2305  if (!VerifyOnly) {
2306  // Update the designator with the field declaration.
2307  D->setField(*Field);
2308 
2309  // Make sure that our non-designated initializer list has space
2310  // for a subobject corresponding to this field.
2311  if (FieldIndex >= StructuredList->getNumInits())
2312  StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
2313  }
2314 
2315  // This designator names a flexible array member.
2316  if (Field->getType()->isIncompleteArrayType()) {
2317  bool Invalid = false;
2318  if ((DesigIdx + 1) != DIE->size()) {
2319  // We can't designate an object within the flexible array
2320  // member (because GCC doesn't allow it).
2321  if (!VerifyOnly) {
2323  = DIE->getDesignator(DesigIdx + 1);
2324  SemaRef.Diag(NextD->getLocStart(),
2325  diag::err_designator_into_flexible_array_member)
2326  << SourceRange(NextD->getLocStart(),
2327  DIE->getLocEnd());
2328  SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2329  << *Field;
2330  }
2331  Invalid = true;
2332  }
2333 
2334  if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
2335  !isa<StringLiteral>(DIE->getInit())) {
2336  // The initializer is not an initializer list.
2337  if (!VerifyOnly) {
2338  SemaRef.Diag(DIE->getInit()->getLocStart(),
2339  diag::err_flexible_array_init_needs_braces)
2340  << DIE->getInit()->getSourceRange();
2341  SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2342  << *Field;
2343  }
2344  Invalid = true;
2345  }
2346 
2347  // Check GNU flexible array initializer.
2348  if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
2349  TopLevelObject))
2350  Invalid = true;
2351 
2352  if (Invalid) {
2353  ++Index;
2354  return true;
2355  }
2356 
2357  // Initialize the array.
2358  bool prevHadError = hadError;
2359  unsigned newStructuredIndex = FieldIndex;
2360  unsigned OldIndex = Index;
2361  IList->setInit(Index, DIE->getInit());
2362 
2363  InitializedEntity MemberEntity =
2364  InitializedEntity::InitializeMember(*Field, &Entity);
2365  CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
2366  StructuredList, newStructuredIndex);
2367 
2368  IList->setInit(OldIndex, DIE);
2369  if (hadError && !prevHadError) {
2370  ++Field;
2371  ++FieldIndex;
2372  if (NextField)
2373  *NextField = Field;
2374  StructuredIndex = FieldIndex;
2375  return true;
2376  }
2377  } else {
2378  // Recurse to check later designated subobjects.
2379  QualType FieldType = Field->getType();
2380  unsigned newStructuredIndex = FieldIndex;
2381 
2382  InitializedEntity MemberEntity =
2383  InitializedEntity::InitializeMember(*Field, &Entity);
2384  if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2385  FieldType, nullptr, nullptr, Index,
2386  StructuredList, newStructuredIndex,
2387  FinishSubobjectInit, false))
2388  return true;
2389  }
2390 
2391  // Find the position of the next field to be initialized in this
2392  // subobject.
2393  ++Field;
2394  ++FieldIndex;
2395 
2396  // If this the first designator, our caller will continue checking
2397  // the rest of this struct/class/union subobject.
2398  if (IsFirstDesignator) {
2399  if (NextField)
2400  *NextField = Field;
2401  StructuredIndex = FieldIndex;
2402  return false;
2403  }
2404 
2405  if (!FinishSubobjectInit)
2406  return false;
2407 
2408  // We've already initialized something in the union; we're done.
2409  if (RT->getDecl()->isUnion())
2410  return hadError;
2411 
2412  // Check the remaining fields within this class/struct/union subobject.
2413  bool prevHadError = hadError;
2414 
2415  auto NoBases =
2418  CheckStructUnionTypes(Entity, IList, CurrentObjectType, NoBases, Field,
2419  false, Index, StructuredList, FieldIndex);
2420  return hadError && !prevHadError;
2421  }
2422 
2423  // C99 6.7.8p6:
2424  //
2425  // If a designator has the form
2426  //
2427  // [ constant-expression ]
2428  //
2429  // then the current object (defined below) shall have array
2430  // type and the expression shall be an integer constant
2431  // expression. If the array is of unknown size, any
2432  // nonnegative value is valid.
2433  //
2434  // Additionally, cope with the GNU extension that permits
2435  // designators of the form
2436  //
2437  // [ constant-expression ... constant-expression ]
2438  const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
2439  if (!AT) {
2440  if (!VerifyOnly)
2441  SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
2442  << CurrentObjectType;
2443  ++Index;
2444  return true;
2445  }
2446 
2447  Expr *IndexExpr = nullptr;
2448  llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2449  if (D->isArrayDesignator()) {
2450  IndexExpr = DIE->getArrayIndex(*D);
2451  DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
2452  DesignatedEndIndex = DesignatedStartIndex;
2453  } else {
2454  assert(D->isArrayRangeDesignator() && "Need array-range designator");
2455 
2456  DesignatedStartIndex =
2458  DesignatedEndIndex =
2459  DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
2460  IndexExpr = DIE->getArrayRangeEnd(*D);
2461 
2462  // Codegen can't handle evaluating array range designators that have side
2463  // effects, because we replicate the AST value for each initialized element.
2464  // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
2465  // elements with something that has a side effect, so codegen can emit an
2466  // "error unsupported" error instead of miscompiling the app.
2467  if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
2468  DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
2469  FullyStructuredList->sawArrayRangeDesignator();
2470  }
2471 
2472  if (isa<ConstantArrayType>(AT)) {
2473  llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
2474  DesignatedStartIndex
2475  = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
2476  DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
2477  DesignatedEndIndex
2478  = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
2479  DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2480  if (DesignatedEndIndex >= MaxElements) {
2481  if (!VerifyOnly)
2482  SemaRef.Diag(IndexExpr->getLocStart(),
2483  diag::err_array_designator_too_large)
2484  << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
2485  << IndexExpr->getSourceRange();
2486  ++Index;
2487  return true;
2488  }
2489  } else {
2490  unsigned DesignatedIndexBitWidth =
2491  ConstantArrayType::getMaxSizeBits(SemaRef.Context);
2492  DesignatedStartIndex =
2493  DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
2494  DesignatedEndIndex =
2495  DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
2496  DesignatedStartIndex.setIsUnsigned(true);
2497  DesignatedEndIndex.setIsUnsigned(true);
2498  }
2499 
2500  if (!VerifyOnly && StructuredList->isStringLiteralInit()) {
2501  // We're modifying a string literal init; we have to decompose the string
2502  // so we can modify the individual characters.
2503  ASTContext &Context = SemaRef.Context;
2504  Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2505 
2506  // Compute the character type
2507  QualType CharTy = AT->getElementType();
2508 
2509  // Compute the type of the integer literals.
2510  QualType PromotedCharTy = CharTy;
2511  if (CharTy->isPromotableIntegerType())
2512  PromotedCharTy = Context.getPromotedIntegerType(CharTy);
2513  unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
2514 
2515  if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
2516  // Get the length of the string.
2517  uint64_t StrLen = SL->getLength();
2518  if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2519  StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2520  StructuredList->resizeInits(Context, StrLen);
2521 
2522  // Build a literal for each character in the string, and put them into
2523  // the init list.
2524  for (unsigned i = 0, e = StrLen; i != e; ++i) {
2525  llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2526  Expr *Init = new (Context) IntegerLiteral(
2527  Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2528  if (CharTy != PromotedCharTy)
2529  Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2530  Init, nullptr, VK_RValue);
2531  StructuredList->updateInit(Context, i, Init);
2532  }
2533  } else {
2534  ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
2535  std::string Str;
2536  Context.getObjCEncodingForType(E->getEncodedType(), Str);
2537 
2538  // Get the length of the string.
2539  uint64_t StrLen = Str.size();
2540  if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2541  StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2542  StructuredList->resizeInits(Context, StrLen);
2543 
2544  // Build a literal for each character in the string, and put them into
2545  // the init list.
2546  for (unsigned i = 0, e = StrLen; i != e; ++i) {
2547  llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2548  Expr *Init = new (Context) IntegerLiteral(
2549  Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2550  if (CharTy != PromotedCharTy)
2551  Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2552  Init, nullptr, VK_RValue);
2553  StructuredList->updateInit(Context, i, Init);
2554  }
2555  }
2556  }
2557 
2558  // Make sure that our non-designated initializer list has space
2559  // for a subobject corresponding to this array element.
2560  if (!VerifyOnly &&
2561  DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
2562  StructuredList->resizeInits(SemaRef.Context,
2563  DesignatedEndIndex.getZExtValue() + 1);
2564 
2565  // Repeatedly perform subobject initializations in the range
2566  // [DesignatedStartIndex, DesignatedEndIndex].
2567 
2568  // Move to the next designator
2569  unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
2570  unsigned OldIndex = Index;
2571 
2572  InitializedEntity ElementEntity =
2573  InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
2574 
2575  while (DesignatedStartIndex <= DesignatedEndIndex) {
2576  // Recurse to check later designated subobjects.
2577  QualType ElementType = AT->getElementType();
2578  Index = OldIndex;
2579 
2580  ElementEntity.setElementIndex(ElementIndex);
2581  if (CheckDesignatedInitializer(
2582  ElementEntity, IList, DIE, DesigIdx + 1, ElementType, nullptr,
2583  nullptr, Index, StructuredList, ElementIndex,
2584  FinishSubobjectInit && (DesignatedStartIndex == DesignatedEndIndex),
2585  false))
2586  return true;
2587 
2588  // Move to the next index in the array that we'll be initializing.
2589  ++DesignatedStartIndex;
2590  ElementIndex = DesignatedStartIndex.getZExtValue();
2591  }
2592 
2593  // If this the first designator, our caller will continue checking
2594  // the rest of this array subobject.
2595  if (IsFirstDesignator) {
2596  if (NextElementIndex)
2597  *NextElementIndex = DesignatedStartIndex;
2598  StructuredIndex = ElementIndex;
2599  return false;
2600  }
2601 
2602  if (!FinishSubobjectInit)
2603  return false;
2604 
2605  // Check the remaining elements within this array subobject.
2606  bool prevHadError = hadError;
2607  CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
2608  /*SubobjectIsDesignatorContext=*/false, Index,
2609  StructuredList, ElementIndex);
2610  return hadError && !prevHadError;
2611 }
2612 
2613 // Get the structured initializer list for a subobject of type
2614 // @p CurrentObjectType.
2615 InitListExpr *
2616 InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2617  QualType CurrentObjectType,
2618  InitListExpr *StructuredList,
2619  unsigned StructuredIndex,
2620  SourceRange InitRange,
2621  bool IsFullyOverwritten) {
2622  if (VerifyOnly)
2623  return nullptr; // No structured list in verification-only mode.
2624  Expr *ExistingInit = nullptr;
2625  if (!StructuredList)
2626  ExistingInit = SyntacticToSemantic.lookup(IList);
2627  else if (StructuredIndex < StructuredList->getNumInits())
2628  ExistingInit = StructuredList->getInit(StructuredIndex);
2629 
2630  if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2631  // There might have already been initializers for subobjects of the current
2632  // object, but a subsequent initializer list will overwrite the entirety
2633  // of the current object. (See DR 253 and C99 6.7.8p21). e.g.,
2634  //
2635  // struct P { char x[6]; };
2636  // struct P l = { .x[2] = 'x', .x = { [0] = 'f' } };
2637  //
2638  // The first designated initializer is ignored, and l.x is just "f".
2639  if (!IsFullyOverwritten)
2640  return Result;
2641 
2642  if (ExistingInit) {
2643  // We are creating an initializer list that initializes the
2644  // subobjects of the current object, but there was already an
2645  // initialization that completely initialized the current
2646  // subobject, e.g., by a compound literal:
2647  //
2648  // struct X { int a, b; };
2649  // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2650  //
2651  // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2652  // designated initializer re-initializes the whole
2653  // subobject [0], overwriting previous initializers.
2654  SemaRef.Diag(InitRange.getBegin(),
2655  diag::warn_subobject_initializer_overrides)
2656  << InitRange;
2657  SemaRef.Diag(ExistingInit->getLocStart(),
2658  diag::note_previous_initializer)
2659  << /*FIXME:has side effects=*/0
2660  << ExistingInit->getSourceRange();
2661  }
2662 
2663  InitListExpr *Result
2664  = new (SemaRef.Context) InitListExpr(SemaRef.Context,
2665  InitRange.getBegin(), None,
2666  InitRange.getEnd());
2667 
2668  QualType ResultType = CurrentObjectType;
2669  if (!ResultType->isArrayType())
2670  ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2671  Result->setType(ResultType);
2672 
2673  // Pre-allocate storage for the structured initializer list.
2674  unsigned NumElements = 0;
2675  unsigned NumInits = 0;
2676  bool GotNumInits = false;
2677  if (!StructuredList) {
2678  NumInits = IList->getNumInits();
2679  GotNumInits = true;
2680  } else if (Index < IList->getNumInits()) {
2681  if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
2682  NumInits = SubList->getNumInits();
2683  GotNumInits = true;
2684  }
2685  }
2686 
2687  if (const ArrayType *AType
2688  = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2689  if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2690  NumElements = CAType->getSize().getZExtValue();
2691  // Simple heuristic so that we don't allocate a very large
2692  // initializer with many empty entries at the end.
2693  if (GotNumInits && NumElements > NumInits)
2694  NumElements = 0;
2695  }
2696  } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
2697  NumElements = VType->getNumElements();
2698  else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
2699  RecordDecl *RDecl = RType->getDecl();
2700  if (RDecl->isUnion())
2701  NumElements = 1;
2702  else
2703  NumElements = std::distance(RDecl->field_begin(), RDecl->field_end());
2704  }
2705 
2706  Result->reserveInits(SemaRef.Context, NumElements);
2707 
2708  // Link this new initializer list into the structured initializer
2709  // lists.
2710  if (StructuredList)
2711  StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
2712  else {
2713  Result->setSyntacticForm(IList);
2714  SyntacticToSemantic[IList] = Result;
2715  }
2716 
2717  return Result;
2718 }
2719 
2720 /// Update the initializer at index @p StructuredIndex within the
2721 /// structured initializer list to the value @p expr.
2722 void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2723  unsigned &StructuredIndex,
2724  Expr *expr) {
2725  // No structured initializer list to update
2726  if (!StructuredList)
2727  return;
2728 
2729  if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2730  StructuredIndex, expr)) {
2731  // This initializer overwrites a previous initializer. Warn.
2732  // We need to check on source range validity because the previous
2733  // initializer does not have to be an explicit initializer.
2734  // struct P { int a, b; };
2735  // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2736  // There is an overwrite taking place because the first braced initializer
2737  // list "{ .a = 2 }' already provides value for .p.b (which is zero).
2738  if (PrevInit->getSourceRange().isValid()) {
2739  SemaRef.Diag(expr->getLocStart(),
2740  diag::warn_initializer_overrides)
2741  << expr->getSourceRange();
2742 
2743  SemaRef.Diag(PrevInit->getLocStart(),
2744  diag::note_previous_initializer)
2745  << /*FIXME:has side effects=*/0
2746  << PrevInit->getSourceRange();
2747  }
2748  }
2749 
2750  ++StructuredIndex;
2751 }
2752 
2753 /// Check that the given Index expression is a valid array designator
2754 /// value. This is essentially just a wrapper around
2755 /// VerifyIntegerConstantExpression that also checks for negative values
2756 /// and produces a reasonable diagnostic if there is a
2757 /// failure. Returns the index expression, possibly with an implicit cast
2758 /// added, on success. If everything went okay, Value will receive the
2759 /// value of the constant expression.
2760 static ExprResult
2761 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
2762  SourceLocation Loc = Index->getLocStart();
2763 
2764  // Make sure this is an integer constant expression.
2765  ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value);
2766  if (Result.isInvalid())
2767  return Result;
2768 
2769  if (Value.isSigned() && Value.isNegative())
2770  return S.Diag(Loc, diag::err_array_designator_negative)
2771  << Value.toString(10) << Index->getSourceRange();
2772 
2773  Value.setIsUnsigned(true);
2774  return Result;
2775 }
2776 
2777 ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
2778  SourceLocation Loc,
2779  bool GNUSyntax,
2780  ExprResult Init) {
2781  typedef DesignatedInitExpr::Designator ASTDesignator;
2782 
2783  bool Invalid = false;
2784  SmallVector<ASTDesignator, 32> Designators;
2785  SmallVector<Expr *, 32> InitExpressions;
2786 
2787  // Build designators and check array designator expressions.
2788  for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2789  const Designator &D = Desig.getDesignator(Idx);
2790  switch (D.getKind()) {
2792  Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
2793  D.getFieldLoc()));
2794  break;
2795 
2797  Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2798  llvm::APSInt IndexValue;
2799  if (!Index->isTypeDependent() && !Index->isValueDependent())
2800  Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get();
2801  if (!Index)
2802  Invalid = true;
2803  else {
2804  Designators.push_back(ASTDesignator(InitExpressions.size(),
2805  D.getLBracketLoc(),
2806  D.getRBracketLoc()));
2807  InitExpressions.push_back(Index);
2808  }
2809  break;
2810  }
2811 
2813  Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
2814  Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
2815  llvm::APSInt StartValue;
2816  llvm::APSInt EndValue;
2817  bool StartDependent = StartIndex->isTypeDependent() ||
2818  StartIndex->isValueDependent();
2819  bool EndDependent = EndIndex->isTypeDependent() ||
2820  EndIndex->isValueDependent();
2821  if (!StartDependent)
2822  StartIndex =
2823  CheckArrayDesignatorExpr(*this, StartIndex, StartValue).get();
2824  if (!EndDependent)
2825  EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).get();
2826 
2827  if (!StartIndex || !EndIndex)
2828  Invalid = true;
2829  else {
2830  // Make sure we're comparing values with the same bit width.
2831  if (StartDependent || EndDependent) {
2832  // Nothing to compute.
2833  } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
2834  EndValue = EndValue.extend(StartValue.getBitWidth());
2835  else if (StartValue.getBitWidth() < EndValue.getBitWidth())
2836  StartValue = StartValue.extend(EndValue.getBitWidth());
2837 
2838  if (!StartDependent && !EndDependent && EndValue < StartValue) {
2839  Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
2840  << StartValue.toString(10) << EndValue.toString(10)
2841  << StartIndex->getSourceRange() << EndIndex->getSourceRange();
2842  Invalid = true;
2843  } else {
2844  Designators.push_back(ASTDesignator(InitExpressions.size(),
2845  D.getLBracketLoc(),
2846  D.getEllipsisLoc(),
2847  D.getRBracketLoc()));
2848  InitExpressions.push_back(StartIndex);
2849  InitExpressions.push_back(EndIndex);
2850  }
2851  }
2852  break;
2853  }
2854  }
2855  }
2856 
2857  if (Invalid || Init.isInvalid())
2858  return ExprError();
2859 
2860  // Clear out the expressions within the designation.
2861  Desig.ClearExprs(*this);
2862 
2863  DesignatedInitExpr *DIE
2864  = DesignatedInitExpr::Create(Context,
2865  Designators,
2866  InitExpressions, Loc, GNUSyntax,
2867  Init.getAs<Expr>());
2868 
2869  if (!getLangOpts().C99)
2870  Diag(DIE->getLocStart(), diag::ext_designated_init)
2871  << DIE->getSourceRange();
2872 
2873  return DIE;
2874 }
2875 
2876 //===----------------------------------------------------------------------===//
2877 // Initialization entity
2878 //===----------------------------------------------------------------------===//
2879 
2880 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
2881  const InitializedEntity &Parent)
2882  : Parent(&Parent), Index(Index)
2883 {
2884  if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
2885  Kind = EK_ArrayElement;
2886  Type = AT->getElementType();
2887  } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
2888  Kind = EK_VectorElement;
2889  Type = VT->getElementType();
2890  } else {
2891  const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
2892  assert(CT && "Unexpected type");
2893  Kind = EK_ComplexElement;
2894  Type = CT->getElementType();
2895  }
2896 }
2897 
2900  const CXXBaseSpecifier *Base,
2901  bool IsInheritedVirtualBase,
2902  const InitializedEntity *Parent) {
2904  Result.Kind = EK_Base;
2905  Result.Parent = Parent;
2906  Result.Base = reinterpret_cast<uintptr_t>(Base);
2907  if (IsInheritedVirtualBase)
2908  Result.Base |= 0x01;
2909 
2910  Result.Type = Base->getType();
2911  return Result;
2912 }
2913 
2915  switch (getKind()) {
2916  case EK_Parameter:
2917  case EK_Parameter_CF_Audited: {
2918  ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2919  return (D ? D->getDeclName() : DeclarationName());
2920  }
2921 
2922  case EK_Variable:
2923  case EK_Member:
2924  case EK_Binding:
2925  return Variable.VariableOrMember->getDeclName();
2926 
2927  case EK_LambdaCapture:
2928  return DeclarationName(Capture.VarID);
2929 
2930  case EK_Result:
2931  case EK_Exception:
2932  case EK_New:
2933  case EK_Temporary:
2934  case EK_Base:
2935  case EK_Delegating:
2936  case EK_ArrayElement:
2937  case EK_VectorElement:
2938  case EK_ComplexElement:
2939  case EK_BlockElement:
2942  case EK_RelatedResult:
2943  return DeclarationName();
2944  }
2945 
2946  llvm_unreachable("Invalid EntityKind!");
2947 }
2948 
2950  switch (getKind()) {
2951  case EK_Variable:
2952  case EK_Member:
2953  case EK_Binding:
2954  return Variable.VariableOrMember;
2955 
2956  case EK_Parameter:
2958  return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2959 
2960  case EK_Result:
2961  case EK_Exception:
2962  case EK_New:
2963  case EK_Temporary:
2964  case EK_Base:
2965  case EK_Delegating:
2966  case EK_ArrayElement:
2967  case EK_VectorElement:
2968  case EK_ComplexElement:
2969  case EK_BlockElement:
2971  case EK_LambdaCapture:
2973  case EK_RelatedResult:
2974  return nullptr;
2975  }
2976 
2977  llvm_unreachable("Invalid EntityKind!");
2978 }
2979 
2981  switch (getKind()) {
2982  case EK_Result:
2983  case EK_Exception:
2984  return LocAndNRVO.NRVO;
2985 
2986  case EK_Variable:
2987  case EK_Parameter:
2989  case EK_Member:
2990  case EK_Binding:
2991  case EK_New:
2992  case EK_Temporary:
2994  case EK_Base:
2995  case EK_Delegating:
2996  case EK_ArrayElement:
2997  case EK_VectorElement:
2998  case EK_ComplexElement:
2999  case EK_BlockElement:
3001  case EK_LambdaCapture:
3002  case EK_RelatedResult:
3003  break;
3004  }
3005 
3006  return false;
3007 }
3008 
3009 unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
3010  assert(getParent() != this);
3011  unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
3012  for (unsigned I = 0; I != Depth; ++I)
3013  OS << "`-";
3014 
3015  switch (getKind()) {
3016  case EK_Variable: OS << "Variable"; break;
3017  case EK_Parameter: OS << "Parameter"; break;
3018  case EK_Parameter_CF_Audited: OS << "CF audited function Parameter";
3019  break;
3020  case EK_Result: OS << "Result"; break;
3021  case EK_Exception: OS << "Exception"; break;
3022  case EK_Member: OS << "Member"; break;
3023  case EK_Binding: OS << "Binding"; break;
3024  case EK_New: OS << "New"; break;
3025  case EK_Temporary: OS << "Temporary"; break;
3026  case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
3027  case EK_RelatedResult: OS << "RelatedResult"; break;
3028  case EK_Base: OS << "Base"; break;
3029  case EK_Delegating: OS << "Delegating"; break;
3030  case EK_ArrayElement: OS << "ArrayElement " << Index; break;
3031  case EK_VectorElement: OS << "VectorElement " << Index; break;
3032  case EK_ComplexElement: OS << "ComplexElement " << Index; break;
3033  case EK_BlockElement: OS << "Block"; break;
3035  OS << "Block (lambda)";
3036  break;
3037  case EK_LambdaCapture:
3038  OS << "LambdaCapture ";
3039  OS << DeclarationName(Capture.VarID);
3040  break;
3041  }
3042 
3043  if (auto *D = getDecl()) {
3044  OS << " ";
3045  D->printQualifiedName(OS);
3046  }
3047 
3048  OS << " '" << getType().getAsString() << "'\n";
3049 
3050  return Depth + 1;
3051 }
3052 
3053 LLVM_DUMP_METHOD void InitializedEntity::dump() const {
3054  dumpImpl(llvm::errs());
3055 }
3056 
3057 //===----------------------------------------------------------------------===//
3058 // Initialization sequence
3059 //===----------------------------------------------------------------------===//
3060 
3062  switch (Kind) {
3067  case SK_BindReference:
3069  case SK_FinalCopy:
3071  case SK_UserConversion:
3075  case SK_AtomicConversion:
3076  case SK_LValueToRValue:
3077  case SK_ListInitialization:
3078  case SK_UnwrapInitList:
3079  case SK_RewrapInitList:
3082  case SK_ZeroInitialization:
3083  case SK_CAssignment:
3084  case SK_StringInit:
3086  case SK_ArrayLoopIndex:
3087  case SK_ArrayLoopInit:
3088  case SK_ArrayInit:
3089  case SK_GNUArrayInit:
3093  case SK_ProduceObjCObject:
3094  case SK_StdInitializerList:
3096  case SK_OCLSamplerInit:
3097  case SK_OCLZeroEvent:
3098  case SK_OCLZeroQueue:
3099  break;
3100 
3101  case SK_ConversionSequence:
3103  delete ICS;
3104  }
3105 }
3106 
3108  // There can be some lvalue adjustments after the SK_BindReference step.
3109  for (auto I = Steps.rbegin(); I != Steps.rend(); ++I) {
3110  if (I->Kind == SK_BindReference)
3111  return true;
3112  if (I->Kind == SK_BindReferenceToTemporary)
3113  return false;
3114  }
3115  return false;
3116 }
3117 
3119  if (!Failed())
3120  return false;
3121 
3122  switch (getFailureKind()) {
3125  case FK_ArrayNeedsInitList:
3131  case FK_AddressOfOverloadFailed: // FIXME: Could do better
3139  case FK_ConversionFailed:
3145  case FK_DefaultInitOfConst:
3146  case FK_Incomplete:
3147  case FK_ArrayTypeMismatch:
3151  case FK_PlaceholderType:
3154  return false;
3155 
3160  return FailedOverloadResult == OR_Ambiguous;
3161  }
3162 
3163  llvm_unreachable("Invalid EntityKind!");
3164 }
3165 
3167  return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
3168 }
3169 
3170 void
3173  DeclAccessPair Found,
3174  bool HadMultipleCandidates) {
3175  Step S;
3177  S.Type = Function->getType();
3178  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3179  S.Function.Function = Function;
3180  S.Function.FoundDecl = Found;
3181  Steps.push_back(S);
3182 }
3183 
3185  ExprValueKind VK) {
3186  Step S;
3187  switch (VK) {
3188  case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
3189  case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
3190  case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
3191  }
3192  S.Type = BaseType;
3193  Steps.push_back(S);
3194 }
3195 
3197  bool BindingTemporary) {
3198  Step S;
3199  S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
3200  S.Type = T;
3201  Steps.push_back(S);
3202 }
3203 
3205  Step S;
3206  S.Kind = SK_FinalCopy;
3207  S.Type = T;
3208  Steps.push_back(S);
3209 }
3210 
3212  Step S;
3214  S.Type = T;
3215  Steps.push_back(S);
3216 }
3217 
3218 void
3221  QualType T,
3222  bool HadMultipleCandidates) {
3223  Step S;
3224  S.Kind = SK_UserConversion;
3225  S.Type = T;
3226  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3227  S.Function.Function = Function;
3229  Steps.push_back(S);
3230 }
3231 
3233  ExprValueKind VK) {
3234  Step S;
3235  S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
3236  switch (VK) {
3237  case VK_RValue:
3239  break;
3240  case VK_XValue:
3242  break;
3243  case VK_LValue:
3245  break;
3246  }
3247  S.Type = Ty;
3248  Steps.push_back(S);
3249 }
3250 
3252  Step S;
3254  S.Type = Ty;
3255  Steps.push_back(S);
3256 }
3257 
3259  assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
3260 
3261  Step S;
3262  S.Kind = SK_LValueToRValue;
3263  S.Type = Ty;
3264  Steps.push_back(S);
3265 }
3266 
3268  const ImplicitConversionSequence &ICS, QualType T,
3269  bool TopLevelOfInitList) {
3270  Step S;
3271  S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing
3273  S.Type = T;
3274  S.ICS = new ImplicitConversionSequence(ICS);
3275  Steps.push_back(S);
3276 }
3277 
3279  Step S;
3281  S.Type = T;
3282  Steps.push_back(S);
3283 }
3284 
3287  bool HadMultipleCandidates, bool FromInitList, bool AsInitList) {
3288  Step S;
3289  S.Kind = FromInitList ? AsInitList ? SK_StdInitializerListConstructorCall
3292  S.Type = T;
3293  S.Function.HadMultipleCandidates = HadMultipleCandidates;
3294  S.Function.Function = Constructor;
3296  Steps.push_back(S);
3297 }
3298 
3300  Step S;
3302  S.Type = T;
3303  Steps.push_back(S);
3304 }
3305 
3307  Step S;
3308  S.Kind = SK_CAssignment;
3309  S.Type = T;
3310  Steps.push_back(S);
3311 }
3312 
3314  Step S;
3315  S.Kind = SK_StringInit;
3316  S.Type = T;
3317  Steps.push_back(S);
3318 }
3319 
3321  Step S;
3323  S.Type = T;
3324  Steps.push_back(S);
3325 }
3326 
3328  Step S;
3329  S.Kind = IsGNUExtension ? SK_GNUArrayInit : SK_ArrayInit;
3330  S.Type = T;
3331  Steps.push_back(S);
3332 }
3333 
3335  Step S;
3336  S.Kind = SK_ArrayLoopIndex;
3337  S.Type = EltT;
3338  Steps.insert(Steps.begin(), S);
3339 
3340  S.Kind = SK_ArrayLoopInit;
3341  S.Type = T;
3342  Steps.push_back(S);
3343 }
3344 
3346  Step S;
3348  S.Type = T;
3349  Steps.push_back(S);
3350 }
3351 
3353  bool shouldCopy) {
3354  Step s;
3355  s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
3357  s.Type = type;
3358  Steps.push_back(s);
3359 }
3360 
3362  Step S;
3364  S.Type = T;
3365  Steps.push_back(S);
3366 }
3367 
3369  Step S;
3371  S.Type = T;
3372  Steps.push_back(S);
3373 }
3374 
3376  Step S;
3377  S.Kind = SK_OCLSamplerInit;
3378  S.Type = T;
3379  Steps.push_back(S);
3380 }
3381 
3383  Step S;
3384  S.Kind = SK_OCLZeroEvent;
3385  S.Type = T;
3386  Steps.push_back(S);
3387 }
3388 
3390  Step S;
3391  S.Kind = SK_OCLZeroQueue;
3392  S.Type = T;
3393  Steps.push_back(S);
3394 }
3395 
3397  InitListExpr *Syntactic) {
3398  assert(Syntactic->getNumInits() == 1 &&
3399  "Can only rewrap trivial init lists.");
3400  Step S;
3401  S.Kind = SK_UnwrapInitList;
3402  S.Type = Syntactic->getInit(0)->getType();
3403  Steps.insert(Steps.begin(), S);
3404 
3405  S.Kind = SK_RewrapInitList;
3406  S.Type = T;
3407  S.WrappingSyntacticList = Syntactic;
3408  Steps.push_back(S);
3409 }
3410 
3412  OverloadingResult Result) {
3414  this->Failure = Failure;
3415  this->FailedOverloadResult = Result;
3416 }
3417 
3418 //===----------------------------------------------------------------------===//
3419 // Attempt initialization
3420 //===----------------------------------------------------------------------===//
3421 
3422 /// Tries to add a zero initializer. Returns true if that worked.
3423 static bool
3425  const InitializedEntity &Entity) {
3426  if (Entity.getKind() != InitializedEntity::EK_Variable)
3427  return false;
3428 
3429  VarDecl *VD = cast<VarDecl>(Entity.getDecl());
3430  if (VD->getInit() || VD->getLocEnd().isMacroID())
3431  return false;
3432 
3433  QualType VariableTy = VD->getType().getCanonicalType();
3435  std::string Init = S.getFixItZeroInitializerForType(VariableTy, Loc);
3436  if (!Init.empty()) {
3437  Sequence.AddZeroInitializationStep(Entity.getType());
3438  Sequence.SetZeroInitializationFixit(Init, Loc);
3439  return true;
3440  }
3441  return false;
3442 }
3443 
3445  InitializationSequence &Sequence,
3446  const InitializedEntity &Entity) {
3447  if (!S.getLangOpts().ObjCAutoRefCount) return;
3448 
3449  /// When initializing a parameter, produce the value if it's marked
3450  /// __attribute__((ns_consumed)).
3451  if (Entity.isParameterKind()) {
3452  if (!Entity.isParameterConsumed())
3453  return;
3454 
3455  assert(Entity.getType()->isObjCRetainableType() &&
3456  "consuming an object of unretainable type?");
3457  Sequence.AddProduceObjCObjectStep(Entity.getType());
3458 
3459  /// When initializing a return value, if the return type is a
3460  /// retainable type, then returns need to immediately retain the
3461  /// object. If an autorelease is required, it will be done at the
3462  /// last instant.
3463  } else if (Entity.getKind() == InitializedEntity::EK_Result) {
3464  if (!Entity.getType()->isObjCRetainableType())
3465  return;
3466 
3467  Sequence.AddProduceObjCObjectStep(Entity.getType());
3468  }
3469 }
3470 
3471 static void TryListInitialization(Sema &S,
3472  const InitializedEntity &Entity,
3473  const InitializationKind &Kind,
3474  InitListExpr *InitList,
3475  InitializationSequence &Sequence,
3476  bool TreatUnavailableAsInvalid);
3477 
3478 /// \brief When initializing from init list via constructor, handle
3479 /// initialization of an object of type std::initializer_list<T>.
3480 ///
3481 /// \return true if we have handled initialization of an object of type
3482 /// std::initializer_list<T>, false otherwise.
3484  InitListExpr *List,
3485  QualType DestType,
3486  InitializationSequence &Sequence,
3487  bool TreatUnavailableAsInvalid) {
3488  QualType E;
3489  if (!S.isStdInitializerList(DestType, &E))
3490  return false;
3491 
3492  if (!S.isCompleteType(List->getExprLoc(), E)) {
3493  Sequence.setIncompleteTypeFailure(E);
3494  return true;
3495  }
3496 
3497  // Try initializing a temporary array from the init list.
3499  E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
3500  List->getNumInits()),
3502  InitializedEntity HiddenArray =
3504  InitializationKind Kind =
3506  TryListInitialization(S, HiddenArray, Kind, List, Sequence,
3507  TreatUnavailableAsInvalid);
3508  if (Sequence)
3509  Sequence.AddStdInitializerListConstructionStep(DestType);
3510  return true;
3511 }
3512 
3513 /// Determine if the constructor has the signature of a copy or move
3514 /// constructor for the type T of the class in which it was found. That is,
3515 /// determine if its first parameter is of type T or reference to (possibly
3516 /// cv-qualified) T.
3518  const ConstructorInfo &Info) {
3519  if (Info.Constructor->getNumParams() == 0)
3520  return false;
3521 
3522  QualType ParmT =
3524  QualType ClassT =
3525  Ctx.getRecordType(cast<CXXRecordDecl>(Info.FoundDecl->getDeclContext()));
3526 
3527  return Ctx.hasSameUnqualifiedType(ParmT, ClassT);
3528 }
3529 
3530 static OverloadingResult
3532  MultiExprArg Args,
3533  OverloadCandidateSet &CandidateSet,
3536  bool CopyInitializing, bool AllowExplicit,
3537  bool OnlyListConstructors, bool IsListInit,
3538  bool SecondStepOfCopyInit = false) {
3539  CandidateSet.clear();
3540 
3541  for (NamedDecl *D : Ctors) {
3542  auto Info = getConstructorInfo(D);
3543  if (!Info.Constructor || Info.Constructor->isInvalidDecl())
3544  continue;
3545 
3546  if (!AllowExplicit && Info.Constructor->isExplicit())
3547  continue;
3548 
3549  if (OnlyListConstructors && !S.isInitListConstructor(Info.Constructor))
3550  continue;
3551 
3552  // C++11 [over.best.ics]p4:
3553  // ... and the constructor or user-defined conversion function is a
3554  // candidate by
3555  // - 13.3.1.3, when the argument is the temporary in the second step
3556  // of a class copy-initialization, or
3557  // - 13.3.1.4, 13.3.1.5, or 13.3.1.6 (in all cases), [not handled here]
3558  // - the second phase of 13.3.1.7 when the initializer list has exactly
3559  // one element that is itself an initializer list, and the target is
3560  // the first parameter of a constructor of class X, and the conversion
3561  // is to X or reference to (possibly cv-qualified X),
3562  // user-defined conversion sequences are not considered.
3563  bool SuppressUserConversions =
3564  SecondStepOfCopyInit ||
3565  (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
3566  hasCopyOrMoveCtorParam(S.Context, Info));
3567 
3568  if (Info.ConstructorTmpl)
3569  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
3570  /*ExplicitArgs*/ nullptr, Args,
3571  CandidateSet, SuppressUserConversions);
3572  else {
3573  // C++ [over.match.copy]p1:
3574  // - When initializing a temporary to be bound to the first parameter
3575  // of a constructor [for type T] that takes a reference to possibly
3576  // cv-qualified T as its first argument, called with a single
3577  // argument in the context of direct-initialization, explicit
3578  // conversion functions are also considered.
3579  // FIXME: What if a constructor template instantiates to such a signature?
3580  bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
3581  Args.size() == 1 &&
3583  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, Args,
3584  CandidateSet, SuppressUserConversions,
3585  /*PartialOverloading=*/false,
3586  /*AllowExplicit=*/AllowExplicitConv);
3587  }
3588  }
3589 
3590  // Perform overload resolution and return the result.
3591  return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3592 }
3593 
3594 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3595 /// enumerates the constructors of the initialized entity and performs overload
3596 /// resolution to select the best.
3597 /// \param DestType The destination class type.
3598 /// \param DestArrayType The destination type, which is either DestType or
3599 /// a (possibly multidimensional) array of DestType.
3600 /// \param IsListInit Is this list-initialization?
3601 /// \param IsInitListCopy Is this non-list-initialization resulting from a
3602 /// list-initialization from {x} where x is the same
3603 /// type as the entity?
3605  const InitializedEntity &Entity,
3606  const InitializationKind &Kind,
3607  MultiExprArg Args, QualType DestType,
3608  QualType DestArrayType,
3609  InitializationSequence &Sequence,
3610  bool IsListInit = false,
3611  bool IsInitListCopy = false) {
3612  assert(((!IsListInit && !IsInitListCopy) ||
3613  (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
3614  "IsListInit/IsInitListCopy must come with a single initializer list "
3615  "argument.");
3616  InitListExpr *ILE =
3617  (IsListInit || IsInitListCopy) ? cast<InitListExpr>(Args[0]) : nullptr;
3618  MultiExprArg UnwrappedArgs =
3619  ILE ? MultiExprArg(ILE->getInits(), ILE->getNumInits()) : Args;
3620 
3621  // The type we're constructing needs to be complete.
3622  if (!S.isCompleteType(Kind.getLocation(), DestType)) {
3623  Sequence.setIncompleteTypeFailure(DestType);
3624  return;
3625  }
3626 
3627  // C++1z [dcl.init]p17:
3628  // - If the initializer expression is a prvalue and the cv-unqualified
3629  // version of the source type is the same class as the class of the
3630  // destination, the initializer expression is used to initialize the
3631  // destination object.
3632  // Per DR (no number yet), this does not apply when initializing a base
3633  // class or delegating to another constructor from a mem-initializer.
3634  // ObjC++: Lambda captured by the block in the lambda to block conversion
3635  // should avoid copy elision.
3636  if (S.getLangOpts().CPlusPlus1z &&
3637  Entity.getKind() != InitializedEntity::EK_Base &&
3639  Entity.getKind() !=
3641  UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isRValue() &&
3642  S.Context.hasSameUnqualifiedType(UnwrappedArgs[0]->getType(), DestType)) {
3643  // Convert qualifications if necessary.
3644  Sequence.AddQualificationConversionStep(DestType, VK_RValue);
3645  if (ILE)
3646  Sequence.RewrapReferenceInitList(DestType, ILE);
3647  return;
3648  }
3649 
3650  const RecordType *DestRecordType = DestType->getAs<RecordType>();
3651  assert(DestRecordType && "Constructor initialization requires record type");
3652  CXXRecordDecl *DestRecordDecl
3653  = cast<CXXRecordDecl>(DestRecordType->getDecl());
3654 
3655  // Build the candidate set directly in the initialization sequence
3656  // structure, so that it will persist if we fail.
3657  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3658 
3659  // Determine whether we are allowed to call explicit constructors or
3660  // explicit conversion operators.
3661  bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
3662  bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
3663 
3664  // - Otherwise, if T is a class type, constructors are considered. The
3665  // applicable constructors are enumerated, and the best one is chosen
3666  // through overload resolution.
3667  DeclContext::lookup_result Ctors = S.LookupConstructors(DestRecordDecl);
3668 
3671  bool AsInitializerList = false;
3672 
3673  // C++11 [over.match.list]p1, per DR1467:
3674  // When objects of non-aggregate type T are list-initialized, such that
3675  // 8.5.4 [dcl.init.list] specifies that overload resolution is performed
3676  // according to the rules in this section, overload resolution selects
3677  // the constructor in two phases:
3678  //
3679  // - Initially, the candidate functions are the initializer-list
3680  // constructors of the class T and the argument list consists of the
3681  // initializer list as a single argument.
3682  if (IsListInit) {
3683  AsInitializerList = true;
3684 
3685  // If the initializer list has no elements and T has a default constructor,
3686  // the first phase is omitted.
3687  if (!(UnwrappedArgs.empty() && DestRecordDecl->hasDefaultConstructor()))
3688  Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3689  CandidateSet, Ctors, Best,
3690  CopyInitialization, AllowExplicit,
3691  /*OnlyListConstructor=*/true,
3692  IsListInit);
3693  }
3694 
3695  // C++11 [over.match.list]p1:
3696  // - If no viable initializer-list constructor is found, overload resolution
3697  // is performed again, where the candidate functions are all the
3698  // constructors of the class T and the argument list consists of the
3699  // elements of the initializer list.
3700  if (Result == OR_No_Viable_Function) {
3701  AsInitializerList = false;
3702  Result = ResolveConstructorOverload(S, Kind.getLocation(), UnwrappedArgs,
3703  CandidateSet, Ctors, Best,
3704  CopyInitialization, AllowExplicit,
3705  /*OnlyListConstructors=*/false,
3706  IsListInit);
3707  }
3708  if (Result) {
3709  Sequence.SetOverloadFailure(IsListInit ?
3712  Result);
3713  return;
3714  }
3715 
3716  // C++11 [dcl.init]p6:
3717  // If a program calls for the default initialization of an object
3718  // of a const-qualified type T, T shall be a class type with a
3719  // user-provided default constructor.
3720  // C++ core issue 253 proposal:
3721  // If the implicit default constructor initializes all subobjects, no
3722  // initializer should be required.
3723  // The 253 proposal is for example needed to process libstdc++ headers in 5.x.
3724  CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3725  if (Kind.getKind() == InitializationKind::IK_Default &&
3726  Entity.getType().isConstQualified()) {
3727  if (!CtorDecl->getParent()->allowConstDefaultInit()) {
3728  if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
3730  return;
3731  }
3732  }
3733 
3734  // C++11 [over.match.list]p1:
3735  // In copy-list-initialization, if an explicit constructor is chosen, the
3736  // initializer is ill-formed.
3737  if (IsListInit && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3739  return;
3740  }
3741 
3742  // Add the constructor initialization step. Any cv-qualification conversion is
3743  // subsumed by the initialization.
3744  bool HadMultipleCandidates = (CandidateSet.size() > 1);
3746  Best->FoundDecl, CtorDecl, DestArrayType, HadMultipleCandidates,
3747  IsListInit | IsInitListCopy, AsInitializerList);
3748 }
3749 
3750 static bool
3752  Expr *Initializer,
3753  QualType &SourceType,
3754  QualType &UnqualifiedSourceType,
3755  QualType UnqualifiedTargetType,
3756  InitializationSequence &Sequence) {
3757  if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
3758  S.Context.OverloadTy) {
3759  DeclAccessPair Found;
3760  bool HadMultipleCandidates = false;
3761  if (FunctionDecl *Fn
3762  = S.ResolveAddressOfOverloadedFunction(Initializer,
3763  UnqualifiedTargetType,
3764  false, Found,
3765  &HadMultipleCandidates)) {
3766  Sequence.AddAddressOverloadResolutionStep(Fn, Found,
3767  HadMultipleCandidates);
3768  SourceType = Fn->getType();
3769  UnqualifiedSourceType = SourceType.getUnqualifiedType();
3770  } else if (!UnqualifiedTargetType->isRecordType()) {
3772  return true;
3773  }
3774  }
3775  return false;
3776 }
3777 
3778 static void TryReferenceInitializationCore(Sema &S,
3779  const InitializedEntity &Entity,
3780  const InitializationKind &Kind,
3781  Expr *Initializer,
3782  QualType cv1T1, QualType T1,
3783  Qualifiers T1Quals,
3784  QualType cv2T2, QualType T2,
3785  Qualifiers T2Quals,
3786  InitializationSequence &Sequence);
3787 
3788 static void TryValueInitialization(Sema &S,
3789  const InitializedEntity &Entity,
3790  const InitializationKind &Kind,
3791  InitializationSequence &Sequence,
3792  InitListExpr *InitList = nullptr);
3793 
3794 /// \brief Attempt list initialization of a reference.
3796  const InitializedEntity &Entity,
3797  const InitializationKind &Kind,
3798  InitListExpr *InitList,
3799  InitializationSequence &Sequence,
3800  bool TreatUnavailableAsInvalid) {
3801  // First, catch C++03 where this isn't possible.
3802  if (!S.getLangOpts().CPlusPlus11) {
3804  return;
3805  }
3806  // Can't reference initialize a compound literal.
3809  return;
3810  }
3811 
3812  QualType DestType = Entity.getType();
3813  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3814  Qualifiers T1Quals;
3815  QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3816 
3817  // Reference initialization via an initializer list works thus:
3818  // If the initializer list consists of a single element that is
3819  // reference-related to the referenced type, bind directly to that element
3820  // (possibly creating temporaries).
3821  // Otherwise, initialize a temporary with the initializer list and
3822  // bind to that.
3823  if (InitList->getNumInits() == 1) {
3824  Expr *Initializer = InitList->getInit(0);
3825  QualType cv2T2 = Initializer->getType();
3826  Qualifiers T2Quals;
3827  QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3828 
3829  // If this fails, creating a temporary wouldn't work either.
3830  if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3831  T1, Sequence))
3832  return;
3833 
3834  SourceLocation DeclLoc = Initializer->getLocStart();
3835  bool dummy1, dummy2, dummy3;
3836  Sema::ReferenceCompareResult RefRelationship
3837  = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3838  dummy2, dummy3);
3839  if (RefRelationship >= Sema::Ref_Related) {
3840  // Try to bind the reference here.
3841  TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3842  T1Quals, cv2T2, T2, T2Quals, Sequence);
3843  if (Sequence)
3844  Sequence.RewrapReferenceInitList(cv1T1, InitList);
3845  return;
3846  }
3847 
3848  // Update the initializer if we've resolved an overloaded function.
3849  if (Sequence.step_begin() != Sequence.step_end())
3850  Sequence.RewrapReferenceInitList(cv1T1, InitList);
3851  }
3852 
3853  // Not reference-related. Create a temporary and bind to that.
3855 
3856  TryListInitialization(S, TempEntity, Kind, InitList, Sequence,
3857  TreatUnavailableAsInvalid);
3858  if (Sequence) {
3859  if (DestType->isRValueReferenceType() ||
3860  (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3861  Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3862  else
3863  Sequence.SetFailed(
3865  }
3866 }
3867 
3868 /// \brief Attempt list initialization (C++0x [dcl.init.list])
3870  const InitializedEntity &Entity,
3871  const InitializationKind &Kind,
3872  InitListExpr *InitList,
3873  InitializationSequence &Sequence,
3874  bool TreatUnavailableAsInvalid) {
3875  QualType DestType = Entity.getType();
3876 
3877  // C++ doesn't allow scalar initialization with more than one argument.
3878  // But C99 complex numbers are scalars and it makes sense there.
3879  if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
3880  !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
3882  return;
3883  }
3884  if (DestType->isReferenceType()) {
3885  TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence,
3886  TreatUnavailableAsInvalid);
3887  return;
3888  }
3889 
3890  if (DestType->isRecordType() &&
3891  !S.isCompleteType(InitList->getLocStart(), DestType)) {
3892  Sequence.setIncompleteTypeFailure(DestType);
3893  return;
3894  }
3895 
3896  // C++11 [dcl.init.list]p3, per DR1467:
3897  // - If T is a class type and the initializer list has a single element of
3898  // type cv U, where U is T or a class derived from T, the object is
3899  // initialized from that element (by copy-initialization for
3900  // copy-list-initialization, or by direct-initialization for
3901  // direct-list-initialization).
3902  // - Otherwise, if T is a character array and the initializer list has a
3903  // single element that is an appropriately-typed string literal
3904  // (8.5.2 [dcl.init.string]), initialization is performed as described
3905  // in that section.
3906  // - Otherwise, if T is an aggregate, [...] (continue below).
3907  if (S.getLangOpts().CPlusPlus11 && InitList->getNumInits() == 1) {
3908  if (DestType->isRecordType()) {
3909  QualType InitType = InitList->getInit(0)->getType();
3910  if (S.Context.hasSameUnqualifiedType(InitType, DestType) ||
3911  S.IsDerivedFrom(InitList->getLocStart(), InitType, DestType)) {
3912  Expr *InitListAsExpr = InitList;
3913  TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
3914  DestType, Sequence,
3915  /*InitListSyntax*/false,
3916  /*IsInitListCopy*/true);
3917  return;
3918  }
3919  }
3920  if (const ArrayType *DestAT = S.Context.getAsArrayType(DestType)) {
3921  Expr *SubInit[1] = {InitList->getInit(0)};
3922  if (!isa<VariableArrayType>(DestAT) &&
3923  IsStringInit(SubInit[0], DestAT, S.Context) == SIF_None) {
3924  InitializationKind SubKind =
3927  InitList->getLBraceLoc(),
3928  InitList->getRBraceLoc())
3929  : Kind;
3930  Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3931  /*TopLevelOfInitList*/ true,
3932  TreatUnavailableAsInvalid);
3933 
3934  // TryStringLiteralInitialization() (in InitializeFrom()) will fail if
3935  // the element is not an appropriately-typed string literal, in which
3936  // case we should proceed as in C++11 (below).
3937  if (Sequence) {
3938  Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3939  return;
3940  }
3941  }
3942  }
3943  }
3944 
3945  // C++11 [dcl.init.list]p3:
3946  // - If T is an aggregate, aggregate initialization is performed.
3947  if ((DestType->isRecordType() && !DestType->isAggregateType()) ||
3948  (S.getLangOpts().CPlusPlus11 &&
3949  S.isStdInitializerList(DestType, nullptr))) {
3950  if (S.getLangOpts().CPlusPlus11) {
3951  // - Otherwise, if the initializer list has no elements and T is a
3952  // class type with a default constructor, the object is
3953  // value-initialized.
3954  if (InitList->getNumInits() == 0) {
3955  CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
3956  if (RD->hasDefaultConstructor()) {
3957  TryValueInitialization(S, Entity, Kind, Sequence, InitList);
3958  return;
3959  }
3960  }
3961 
3962  // - Otherwise, if T is a specialization of std::initializer_list<E>,
3963  // an initializer_list object constructed [...]
3964  if (TryInitializerListConstruction(S, InitList, DestType, Sequence,
3965  TreatUnavailableAsInvalid))
3966  return;
3967 
3968  // - Otherwise, if T is a class type, constructors are considered.
3969  Expr *InitListAsExpr = InitList;
3970  TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
3971  DestType, Sequence, /*InitListSyntax*/true);
3972  } else
3974  return;
3975  }
3976 
3977  if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() &&
3978  InitList->getNumInits() == 1) {
3979  Expr *E = InitList->getInit(0);
3980 
3981  // - Otherwise, if T is an enumeration with a fixed underlying type,
3982  // the initializer-list has a single element v, and the initialization
3983  // is direct-list-initialization, the object is initialized with the
3984  // value T(v); if a narrowing conversion is required to convert v to
3985  // the underlying type of T, the program is ill-formed.
3986  auto *ET = DestType->getAs<EnumType>();
3987  if (S.getLangOpts().CPlusPlus1z &&
3989  ET && ET->getDecl()->isFixed() &&
3990  !S.Context.hasSameUnqualifiedType(E->getType(), DestType) &&
3992  E->getType()->isFloatingType())) {
3993  // There are two ways that T(v) can work when T is an enumeration type.
3994  // If there is either an implicit conversion sequence from v to T or
3995  // a conversion function that can convert from v to T, then we use that.
3996  // Otherwise, if v is of integral, enumeration, or floating-point type,
3997  // it is converted to the enumeration type via its underlying type.
3998  // There is no overlap possible between these two cases (except when the
3999  // source value is already of the destination type), and the first
4000  // case is handled by the general case for single-element lists below.
4002  ICS.setStandard();
4004  if (!E->isRValue())
4006  // If E is of a floating-point type, then the conversion is ill-formed
4007  // due to narrowing, but go through the motions in order to produce the
4008  // right diagnostic.
4009  ICS.Standard.Second = E->getType()->isFloatingType()
4012  ICS.Standard.setFromType(E->getType());
4013  ICS.Standard.setToType(0, E->getType());
4014  ICS.Standard.setToType(1, DestType);
4015  ICS.Standard.setToType(2, DestType);
4016  Sequence.AddConversionSequenceStep(ICS, ICS.Standard.getToType(2),
4017  /*TopLevelOfInitList*/true);
4018  Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
4019  return;
4020  }
4021 
4022  // - Otherwise, if the initializer list has a single element of type E
4023  // [...references are handled above...], the object or reference is
4024  // initialized from that element (by copy-initialization for
4025  // copy-list-initialization, or by direct-initialization for
4026  // direct-list-initialization); if a narrowing conversion is required
4027  // to convert the element to T, the program is ill-formed.
4028  //
4029  // Per core-24034, this is direct-initialization if we were performing
4030  // direct-list-initialization and copy-initialization otherwise.
4031  // We can't use InitListChecker for this, because it always performs
4032  // copy-initialization. This only matters if we might use an 'explicit'
4033  // conversion operator, so we only need to handle the cases where the source
4034  // is of record type.
4035  if (InitList->getInit(0)->getType()->isRecordType()) {
4036  InitializationKind SubKind =
4039  InitList->getLBraceLoc(),
4040  InitList->getRBraceLoc())
4041  : Kind;
4042  Expr *SubInit[1] = { InitList->getInit(0) };
4043  Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
4044  /*TopLevelOfInitList*/true,
4045  TreatUnavailableAsInvalid);
4046  if (Sequence)
4047  Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
4048  return;
4049  }
4050  }
4051 
4052  InitListChecker CheckInitList(S, Entity, InitList,
4053  DestType, /*VerifyOnly=*/true, TreatUnavailableAsInvalid);
4054  if (CheckInitList.HadError()) {
4056  return;
4057  }
4058 
4059  // Add the list initialization step with the built init list.
4060  Sequence.AddListInitializationStep(DestType);
4061 }
4062 
4063 /// \brief Try a reference initialization that involves calling a conversion
4064 /// function.
4066  Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind,
4067  Expr *Initializer, bool AllowRValues, bool IsLValueRef,
4068  InitializationSequence &Sequence) {
4069  QualType DestType = Entity.getType();
4070  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
4071  QualType T1 = cv1T1.getUnqualifiedType();
4072  QualType cv2T2 = Initializer->getType();
4073  QualType T2 = cv2T2.getUnqualifiedType();
4074 
4075  bool DerivedToBase;
4076  bool ObjCConversion;
4077  bool ObjCLifetimeConversion;
4078  assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
4079  T1, T2, DerivedToBase,
4080  ObjCConversion,
4081  ObjCLifetimeConversion) &&
4082  "Must have incompatible references when binding via conversion");
4083  (void)DerivedToBase;
4084  (void)ObjCConversion;
4085  (void)ObjCLifetimeConversion;
4086 
4087  // Build the candidate set directly in the initialization sequence
4088  // structure, so that it will persist if we fail.
4089  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4090  CandidateSet.clear();
4091 
4092  // Determine whether we are allowed to call explicit constructors or
4093  // explicit conversion operators.
4094  bool AllowExplicit = Kind.AllowExplicit();
4095  bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
4096 
4097  const RecordType *T1RecordType = nullptr;
4098  if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
4099  S.isCompleteType(Kind.getLocation(), T1)) {
4100  // The type we're converting to is a class type. Enumerate its constructors
4101  // to see if there is a suitable conversion.
4102  CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
4103 
4104  for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) {
4105  auto Info = getConstructorInfo(D);
4106  if (!Info.Constructor)
4107  continue;
4108 
4109  if (!Info.Constructor->isInvalidDecl() &&
4110  Info.Constructor->isConvertingConstructor(AllowExplicit)) {
4111  if (Info.ConstructorTmpl)
4112  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
4113  /*ExplicitArgs*/ nullptr,
4114  Initializer, CandidateSet,
4115  /*SuppressUserConversions=*/true);
4116  else
4117  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
4118  Initializer, CandidateSet,
4119  /*SuppressUserConversions=*/true);
4120  }
4121  }
4122  }
4123  if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
4124  return OR_No_Viable_Function;
4125 
4126  const RecordType *T2RecordType = nullptr;
4127  if ((T2RecordType = T2->getAs<RecordType>()) &&
4128  S.isCompleteType(Kind.getLocation(), T2)) {
4129  // The type we're converting from is a class type, enumerate its conversion
4130  // functions.
4131  CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
4132 
4133  const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4134  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4135  NamedDecl *D = *I;
4136  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4137  if (isa<UsingShadowDecl>(D))
4138  D = cast<UsingShadowDecl>(D)->getTargetDecl();
4139 
4140  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4141  CXXConversionDecl *Conv;
4142  if (ConvTemplate)
4143  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4144  else
4145  Conv = cast<CXXConversionDecl>(D);
4146 
4147  // If the conversion function doesn't return a reference type,
4148  // it can't be considered for this conversion unless we're allowed to
4149  // consider rvalues.
4150  // FIXME: Do we need to make sure that we only consider conversion
4151  // candidates with reference-compatible results? That might be needed to
4152  // break recursion.
4153  if ((AllowExplicitConvs || !Conv->isExplicit()) &&
4154  (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
4155  if (ConvTemplate)
4156  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4157  ActingDC, Initializer,
4158  DestType, CandidateSet,
4159  /*AllowObjCConversionOnExplicit=*/
4160  false);
4161  else
4162  S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4163  Initializer, DestType, CandidateSet,
4164  /*AllowObjCConversionOnExplicit=*/false);
4165  }
4166  }
4167  }
4168  if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
4169  return OR_No_Viable_Function;
4170 
4171  SourceLocation DeclLoc = Initializer->getLocStart();
4172 
4173  // Perform overload resolution. If it fails, return the failed result.
4175  if (OverloadingResult Result
4176  = CandidateSet.BestViableFunction(S, DeclLoc, Best, true))
4177  return Result;
4178 
4179  FunctionDecl *Function = Best->Function;
4180  // This is the overload that will be used for this initialization step if we
4181  // use this initialization. Mark it as referenced.
4182  Function->setReferenced();
4183 
4184  // Compute the returned type and value kind of the conversion.
4185  QualType cv3T3;
4186  if (isa<CXXConversionDecl>(Function))
4187  cv3T3 = Function->getReturnType();
4188  else
4189  cv3T3 = T1;
4190 
4191  ExprValueKind VK = VK_RValue;
4192  if (cv3T3->isLValueReferenceType())
4193  VK = VK_LValue;
4194  else if (const auto *RRef = cv3T3->getAs<RValueReferenceType>())
4195  VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
4196  cv3T3 = cv3T3.getNonLValueExprType(S.Context);
4197 
4198  // Add the user-defined conversion step.
4199  bool HadMultipleCandidates = (CandidateSet.size() > 1);
4200  Sequence.AddUserConversionStep(Function, Best->FoundDecl, cv3T3,
4201  HadMultipleCandidates);
4202 
4203  // Determine whether we'll need to perform derived-to-base adjustments or
4204  // other conversions.
4205  bool NewDerivedToBase = false;
4206  bool NewObjCConversion = false;
4207  bool NewObjCLifetimeConversion = false;
4208  Sema::ReferenceCompareResult NewRefRelationship
4209  = S.CompareReferenceRelationship(DeclLoc, T1, cv3T3,
4210  NewDerivedToBase, NewObjCConversion,
4211  NewObjCLifetimeConversion);
4212 
4213  // Add the final conversion sequence, if necessary.
4214  if (NewRefRelationship == Sema::Ref_Incompatible) {
4215  assert(!isa<CXXConstructorDecl>(Function) &&
4216  "should not have conversion after constructor");
4217 
4219  ICS.setStandard();
4220  ICS.Standard = Best->FinalConversion;
4221  Sequence.AddConversionSequenceStep(ICS, ICS.Standard.getToType(2));
4222 
4223  // Every implicit conversion results in a prvalue, except for a glvalue
4224  // derived-to-base conversion, which we handle below.
4225  cv3T3 = ICS.Standard.getToType(2);
4226  VK = VK_RValue;
4227  }
4228 
4229  // If the converted initializer is a prvalue, its type T4 is adjusted to
4230  // type "cv1 T4" and the temporary materialization conversion is applied.
4231  //
4232  // We adjust the cv-qualifications to match the reference regardless of
4233  // whether we have a prvalue so that the AST records the change. In this
4234  // case, T4 is "cv3 T3".
4235  QualType cv1T4 = S.Context.getQualifiedType(cv3T3, cv1T1.getQualifiers());
4236  if (cv1T4.getQualifiers() != cv3T3.getQualifiers())
4237  Sequence.AddQualificationConversionStep(cv1T4, VK);
4238  Sequence.AddReferenceBindingStep(cv1T4, VK == VK_RValue);
4239  VK = IsLValueRef ? VK_LValue : VK_XValue;
4240 
4241  if (NewDerivedToBase)
4242  Sequence.AddDerivedToBaseCastStep(cv1T1, VK);
4243  else if (NewObjCConversion)
4244  Sequence.AddObjCObjectConversionStep(cv1T1);
4245 
4246  return OR_Success;
4247 }
4248 
4249 static void CheckCXX98CompatAccessibleCopy(Sema &S,
4250  const InitializedEntity &Entity,
4251  Expr *CurInitExpr);
4252 
4253 /// \brief Attempt reference initialization (C++0x [dcl.init.ref])
4255  const InitializedEntity &Entity,
4256  const InitializationKind &Kind,
4257  Expr *Initializer,
4258  InitializationSequence &Sequence) {
4259  QualType DestType = Entity.getType();
4260  QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
4261  Qualifiers T1Quals;
4262  QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
4263  QualType cv2T2 = Initializer->getType();
4264  Qualifiers T2Quals;
4265  QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
4266 
4267  // If the initializer is the address of an overloaded function, try
4268  // to resolve the overloaded function. If all goes well, T2 is the
4269  // type of the resulting function.
4270  if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
4271  T1, Sequence))
4272  return;
4273 
4274  // Delegate everything else to a subfunction.
4275  TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
4276  T1Quals, cv2T2, T2, T2Quals, Sequence);
4277 }
4278 
4279 /// Determine whether an expression is a non-referenceable glvalue (one to
4280 /// which a reference can never bind). Attemting to bind a reference to
4281 /// such a glvalue will always create a temporary.
4283  return E->refersToBitField() || E->refersToVectorElement();
4284 }
4285 
4286 /// \brief Reference initialization without resolving overloaded functions.
4288  const InitializedEntity &Entity,
4289  const InitializationKind &Kind,
4290  Expr *Initializer,
4291  QualType cv1T1, QualType T1,
4292  Qualifiers T1Quals,
4293  QualType cv2T2, QualType T2,
4294  Qualifiers T2Quals,
4295  InitializationSequence &Sequence) {
4296  QualType DestType = Entity.getType();
4297  SourceLocation DeclLoc = Initializer->getLocStart();
4298  // Compute some basic properties of the types and the initializer.
4299  bool isLValueRef = DestType->isLValueReferenceType();
4300  bool isRValueRef = !isLValueRef;
4301  bool DerivedToBase = false;
4302  bool ObjCConversion = false;
4303  bool ObjCLifetimeConversion = false;
4304  Expr::Classification InitCategory = Initializer->Classify(S.Context);
4305  Sema::ReferenceCompareResult RefRelationship
4306  = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
4307  ObjCConversion, ObjCLifetimeConversion);
4308 
4309  // C++0x [dcl.init.ref]p5:
4310  // A reference to type "cv1 T1" is initialized by an expression of type
4311  // "cv2 T2" as follows:
4312  //
4313  // - If the reference is an lvalue reference and the initializer
4314  // expression
4315  // Note the analogous bullet points for rvalue refs to functions. Because
4316  // there are no function rvalues in C++, rvalue refs to functions are treated
4317  // like lvalue refs.
4318  OverloadingResult ConvOvlResult = OR_Success;
4319  bool T1Function = T1->isFunctionType();
4320  if (isLValueRef || T1Function) {
4321  if (InitCategory.isLValue() && !isNonReferenceableGLValue(Initializer) &&
4322  (RefRelationship == Sema::Ref_Compatible ||
4323  (Kind.isCStyleOrFunctionalCast() &&
4324  RefRelationship == Sema::Ref_Related))) {
4325  // - is an lvalue (but is not a bit-field), and "cv1 T1" is
4326  // reference-compatible with "cv2 T2," or
4327  if (T1Quals != T2Quals)
4328  // Convert to cv1 T2. This should only add qualifiers unless this is a
4329  // c-style cast. The removal of qualifiers in that case notionally
4330  // happens after the reference binding, but that doesn't matter.
4332  S.Context.getQualifiedType(T2, T1Quals),
4333  Initializer->getValueKind());
4334  if (DerivedToBase)
4335  Sequence.AddDerivedToBaseCastStep(cv1T1, VK_LValue);
4336  else if (ObjCConversion)
4337  Sequence.AddObjCObjectConversionStep(cv1T1);
4338 
4339  // We only create a temporary here when binding a reference to a
4340  // bit-field or vector element. Those cases are't supposed to be
4341  // handled by this bullet, but the outcome is the same either way.
4342  Sequence.AddReferenceBindingStep(cv1T1, false);
4343  return;
4344  }
4345 
4346  // - has a class type (i.e., T2 is a class type), where T1 is not
4347  // reference-related to T2, and can be implicitly converted to an
4348  // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
4349  // with "cv3 T3" (this conversion is selected by enumerating the
4350  // applicable conversion functions (13.3.1.6) and choosing the best
4351  // one through overload resolution (13.3)),
4352  // If we have an rvalue ref to function type here, the rhs must be
4353  // an rvalue. DR1287 removed the "implicitly" here.
4354  if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
4355  (isLValueRef || InitCategory.isRValue())) {
4356  ConvOvlResult = TryRefInitWithConversionFunction(
4357  S, Entity, Kind, Initializer, /*AllowRValues*/ isRValueRef,
4358  /*IsLValueRef*/ isLValueRef, Sequence);
4359  if (ConvOvlResult == OR_Success)
4360  return;
4361  if (ConvOvlResult != OR_No_Viable_Function)
4362  Sequence.SetOverloadFailure(
4364  ConvOvlResult);
4365  }
4366  }
4367 
4368  // - Otherwise, the reference shall be an lvalue reference to a
4369  // non-volatile const type (i.e., cv1 shall be const), or the reference
4370  // shall be an rvalue reference.
4371  if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
4372  if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4374  else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4375  Sequence.SetOverloadFailure(
4377  ConvOvlResult);
4378  else if (!InitCategory.isLValue())
4379  Sequence.SetFailed(
4381  else {
4383  switch (RefRelationship) {
4384  case Sema::Ref_Compatible:
4385  if (Initializer->refersToBitField())
4386  FK = InitializationSequence::
4388  else if (Initializer->refersToVectorElement())
4389  FK = InitializationSequence::
4391  else
4392  llvm_unreachable("unexpected kind of compatible initializer");
4393  break;
4394  case Sema::Ref_Related:
4396  break;
4400  break;
4401  }
4402  Sequence.SetFailed(FK);
4403  }
4404  return;
4405  }
4406 
4407  // - If the initializer expression
4408  // - is an
4409  // [<=14] xvalue (but not a bit-field), class prvalue, array prvalue, or
4410  // [1z] rvalue (but not a bit-field) or
4411  // function lvalue and "cv1 T1" is reference-compatible with "cv2 T2"
4412  //
4413  // Note: functions are handled above and below rather than here...
4414  if (!T1Function &&
4415  (RefRelationship == Sema::Ref_Compatible ||
4416  (Kind.isCStyleOrFunctionalCast() &&
4417  RefRelationship == Sema::Ref_Related)) &&
4418  ((InitCategory.isXValue() && !isNonReferenceableGLValue(Initializer)) ||
4419  (InitCategory.isPRValue() &&
4420  (S.getLangOpts().CPlusPlus1z || T2->isRecordType() ||
4421  T2->isArrayType())))) {
4422  ExprValueKind ValueKind = InitCategory.isXValue() ? VK_XValue : VK_RValue;
4423  if (InitCategory.isPRValue() && T2->isRecordType()) {
4424  // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
4425  // compiler the freedom to perform a copy here or bind to the
4426  // object, while C++0x requires that we bind directly to the
4427  // object. Hence, we always bind to the object without making an
4428  // extra copy. However, in C++03 requires that we check for the
4429  // presence of a suitable copy constructor:
4430  //
4431  // The constructor that would be used to make the copy shall
4432  // be callable whether or not the copy is actually done.
4433  if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
4434  Sequence.AddExtraneousCopyToTemporary(cv2T2);
4435  else if (S.getLangOpts().CPlusPlus11)
4436  CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
4437  }
4438 
4439  // C++1z [dcl.init.ref]/5.2.1.2:
4440  // If the converted initializer is a prvalue, its type T4 is adjusted
4441  // to type "cv1 T4" and the temporary materialization conversion is
4442  // applied.
4443  QualType cv1T4 = S.Context.getQualifiedType(cv2T2, T1Quals);
4444  if (T1Quals != T2Quals)
4445  Sequence.AddQualificationConversionStep(cv1T4, ValueKind);
4446  Sequence.AddReferenceBindingStep(cv1T4, ValueKind == VK_RValue);
4447  ValueKind = isLValueRef ? VK_LValue : VK_XValue;
4448 
4449  // In any case, the reference is bound to the resulting glvalue (or to
4450  // an appropriate base class subobject).
4451  if (DerivedToBase)
4452  Sequence.AddDerivedToBaseCastStep(cv1T1, ValueKind);
4453  else if (ObjCConversion)
4454  Sequence.AddObjCObjectConversionStep(cv1T1);
4455  return;
4456  }
4457 
4458  // - has a class type (i.e., T2 is a class type), where T1 is not
4459  // reference-related to T2, and can be implicitly converted to an
4460  // xvalue, class prvalue, or function lvalue of type "cv3 T3",
4461  // where "cv1 T1" is reference-compatible with "cv3 T3",
4462  //
4463  // DR1287 removes the "implicitly" here.
4464  if (T2->isRecordType()) {
4465  if (RefRelationship == Sema::Ref_Incompatible) {
4466  ConvOvlResult = TryRefInitWithConversionFunction(
4467  S, Entity, Kind, Initializer, /*AllowRValues*/ true,
4468  /*IsLValueRef*/ isLValueRef, Sequence);
4469  if (ConvOvlResult)
4470  Sequence.SetOverloadFailure(
4472  ConvOvlResult);
4473 
4474  return;
4475  }
4476 
4477  if (RefRelationship == Sema::Ref_Compatible &&
4478  isRValueRef && InitCategory.isLValue()) {
4479  Sequence.SetFailed(
4481  return;
4482  }
4483 
4485  return;
4486  }
4487 
4488  // - Otherwise, a temporary of type "cv1 T1" is created and initialized
4489  // from the initializer expression using the rules for a non-reference
4490  // copy-initialization (8.5). The reference is then bound to the
4491  // temporary. [...]
4492 
4494 
4495  // FIXME: Why do we use an implicit conversion here rather than trying
4496  // copy-initialization?
4498  = S.TryImplicitConversion(Initializer, TempEntity.getType(),
4499  /*SuppressUserConversions=*/false,
4500  /*AllowExplicit=*/false,
4501  /*FIXME:InOverloadResolution=*/false,
4502  /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4503  /*AllowObjCWritebackConversion=*/false);
4504 
4505  if (ICS.isBad()) {
4506  // FIXME: Use the conversion function set stored in ICS to turn
4507  // this into an overloading ambiguity diagnostic. However, we need
4508  // to keep that set as an OverloadCandidateSet rather than as some
4509  // other kind of set.
4510  if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4511  Sequence.SetOverloadFailure(
4513  ConvOvlResult);
4514  else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4516  else
4518  return;
4519  } else {
4520  Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
4521  }
4522 
4523  // [...] If T1 is reference-related to T2, cv1 must be the
4524  // same cv-qualification as, or greater cv-qualification
4525  // than, cv2; otherwise, the program is ill-formed.
4526  unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
4527  unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
4528  if (RefRelationship == Sema::Ref_Related &&
4529  (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
4531  return;
4532  }
4533 
4534  // [...] If T1 is reference-related to T2 and the reference is an rvalue
4535  // reference, the initializer expression shall not be an lvalue.
4536  if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
4537  InitCategory.isLValue()) {
4538  Sequence.SetFailed(
4540  return;
4541  }
4542 
4543  Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
4544 }
4545 
4546 /// \brief Attempt character array initialization from a string literal
4547 /// (C++ [dcl.init.string], C99 6.7.8).
4549  const InitializedEntity &Entity,
4550  const InitializationKind &Kind,
4551  Expr *Initializer,
4552  InitializationSequence &Sequence) {
4553  Sequence.AddStringInitStep(Entity.getType());
4554 }
4555 
4556 /// \brief Attempt value initialization (C++ [dcl.init]p7).
4558  const InitializedEntity &Entity,
4559  const InitializationKind &Kind,
4560  InitializationSequence &Sequence,
4561  InitListExpr *InitList) {
4562  assert((!InitList || InitList->getNumInits() == 0) &&
4563  "Shouldn't use value-init for non-empty init lists");
4564 
4565  // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
4566  //
4567  // To value-initialize an object of type T means:
4568  QualType T = Entity.getType();
4569 
4570  // -- if T is an array type, then each element is value-initialized;
4571  T = S.Context.getBaseElementType(T);
4572 
4573  if (const RecordType *RT = T->getAs<RecordType>()) {
4574  if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
4575  bool NeedZeroInitialization = true;
4576  // C++98:
4577  // -- if T is a class type (clause 9) with a user-declared constructor
4578  // (12.1), then the default constructor for T is called (and the
4579  // initialization is ill-formed if T has no accessible default
4580  // constructor);
4581  // C++11:
4582  // -- if T is a class type (clause 9) with either no default constructor
4583  // (12.1 [class.ctor]) or a default constructor that is user-provided
4584  // or deleted, then the object is default-initialized;
4585  //
4586  // Note that the C++11 rule is the same as the C++98 rule if there are no
4587  // defaulted or deleted constructors, so we just use it unconditionally.
4588  CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
4589  if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
4590  NeedZeroInitialization = false;
4591 
4592  // -- if T is a (possibly cv-qualified) non-union class type without a
4593  // user-provided or deleted default constructor, then the object is
4594  // zero-initialized and, if T has a non-trivial default constructor,
4595  // default-initialized;
4596  // The 'non-union' here was removed by DR1502. The 'non-trivial default
4597  // constructor' part was removed by DR1507.
4598  if (NeedZeroInitialization)
4599  Sequence.AddZeroInitializationStep(Entity.getType());
4600 
4601  // C++03:
4602  // -- if T is a non-union class type without a user-declared constructor,
4603  // then every non-static data member and base class component of T is
4604  // value-initialized;
4605  // [...] A program that calls for [...] value-initialization of an
4606  // entity of reference type is ill-formed.
4607  //
4608  // C++11 doesn't need this handling, because value-initialization does not
4609  // occur recursively there, and the implicit default constructor is
4610  // defined as deleted in the problematic cases.
4611  if (!S.getLangOpts().CPlusPlus11 &&
4612  ClassDecl->hasUninitializedReferenceMember()) {
4614  return;
4615  }
4616 
4617  // If this is list-value-initialization, pass the empty init list on when
4618  // building the constructor call. This affects the semantics of a few
4619  // things (such as whether an explicit default constructor can be called).
4620  Expr *InitListAsExpr = InitList;
4621  MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
4622  bool InitListSyntax = InitList;
4623 
4624  // FIXME: Instead of creating a CXXConstructExpr of array type here,
4625  // wrap a class-typed CXXConstructExpr in an ArrayInitLoopExpr.
4627  S, Entity, Kind, Args, T, Entity.getType(), Sequence, InitListSyntax);
4628  }
4629  }
4630 
4631  Sequence.AddZeroInitializationStep(Entity.getType());
4632 }
4633 
4634 /// \brief Attempt default initialization (C++ [dcl.init]p6).
4636  const InitializedEntity &Entity,
4637  const InitializationKind &Kind,
4638  InitializationSequence &Sequence) {
4639  assert(Kind.getKind() == InitializationKind::IK_Default);
4640 
4641  // C++ [dcl.init]p6:
4642  // To default-initialize an object of type T means:
4643  // - if T is an array type, each element is default-initialized;
4644  QualType DestType = S.Context.getBaseElementType(Entity.getType());
4645 
4646  // - if T is a (possibly cv-qualified) class type (Clause 9), the default
4647  // constructor for T is called (and the initialization is ill-formed if
4648  // T has no accessible default constructor);
4649  if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
4650  TryConstructorInitialization(S, Entity, Kind, None, DestType,
4651  Entity.getType(), Sequence);
4652  return;
4653  }
4654 
4655  // - otherwise, no initialization is performed.
4656 
4657  // If a program calls for the default initialization of an object of
4658  // a const-qualified type T, T shall be a class type with a user-provided
4659  // default constructor.
4660  if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
4661  if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
4663  return;
4664  }
4665 
4666  // If the destination type has a lifetime property, zero-initialize it.
4667  if (DestType.getQualifiers().hasObjCLifetime()) {
4668  Sequence.AddZeroInitializationStep(Entity.getType());
4669  return;
4670  }
4671 }
4672 
4673 /// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
4674 /// which enumerates all conversion functions and performs overload resolution
4675 /// to select the best.
4677  QualType DestType,
4678  const InitializationKind &Kind,
4679  Expr *Initializer,
4680  InitializationSequence &Sequence,
4681  bool TopLevelOfInitList) {
4682  assert(!DestType->isReferenceType() && "References are handled elsewhere");
4683  QualType SourceType = Initializer->getType();
4684  assert((DestType->isRecordType() || SourceType->isRecordType()) &&
4685  "Must have a class type to perform a user-defined conversion");
4686 
4687  // Build the candidate set directly in the initialization sequence
4688  // structure, so that it will persist if we fail.
4689  OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4690  CandidateSet.clear();
4691 
4692  // Determine whether we are allowed to call explicit constructors or
4693  // explicit conversion operators.
4694  bool AllowExplicit = Kind.AllowExplicit();
4695 
4696  if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4697  // The type we're converting to is a class type. Enumerate its constructors
4698  // to see if there is a suitable conversion.
4699  CXXRecordDecl *DestRecordDecl
4700  = cast<CXXRecordDecl>(DestRecordType->getDecl());
4701 
4702  // Try to complete the type we're converting to.
4703  if (S.isCompleteType(Kind.getLocation(), DestType)) {
4704  for (NamedDecl *D : S.LookupConstructors(DestRecordDecl)) {
4705  auto Info = getConstructorInfo(D);
4706  if (!Info.Constructor)
4707  continue;
4708 
4709  if (!Info.Constructor->isInvalidDecl() &&
4710  Info.Constructor->isConvertingConstructor(AllowExplicit)) {
4711  if (Info.ConstructorTmpl)
4712  S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
4713  /*ExplicitArgs*/ nullptr,
4714  Initializer, CandidateSet,
4715  /*SuppressUserConversions=*/true);
4716  else
4717  S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
4718  Initializer, CandidateSet,
4719  /*SuppressUserConversions=*/true);
4720  }
4721  }
4722  }
4723  }
4724 
4725  SourceLocation DeclLoc = Initializer->getLocStart();
4726 
4727  if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
4728  // The type we're converting from is a class type, enumerate its conversion
4729  // functions.
4730 
4731  // We can only enumerate the conversion functions for a complete type; if
4732  // the type isn't complete, simply skip this step.
4733  if (S.isCompleteType(DeclLoc, SourceType)) {
4734  CXXRecordDecl *SourceRecordDecl
4735  = cast<CXXRecordDecl>(SourceRecordType->getDecl());
4736 
4737  const auto &Conversions =
4738  SourceRecordDecl->getVisibleConversionFunctions();
4739  for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4740  NamedDecl *D = *I;
4741  CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4742  if (isa<UsingShadowDecl>(D))
4743  D = cast<UsingShadowDecl>(D)->getTargetDecl();
4744 
4745  FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4746  CXXConversionDecl *Conv;
4747  if (ConvTemplate)
4748  Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4749  else
4750  Conv = cast<CXXConversionDecl>(D);
4751 
4752  if (AllowExplicit || !Conv->isExplicit()) {
4753  if (ConvTemplate)
4754  S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4755  ActingDC, Initializer, DestType,
4756  CandidateSet, AllowExplicit);
4757  else
4758  S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4759  Initializer, DestType, CandidateSet,
4760  AllowExplicit);
4761  }
4762  }
4763  }
4764  }
4765 
4766  // Perform overload resolution. If it fails, return the failed result.
4768  if (OverloadingResult Result
4769  = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
4770  Sequence.SetOverloadFailure(
4772  Result);
4773  return;
4774  }
4775 
4776  FunctionDecl *Function = Best->Function;
4777  Function->setReferenced();
4778  bool HadMultipleCandidates = (CandidateSet.size() > 1);
4779 
4780  if (isa<CXXConstructorDecl>(Function)) {
4781  // Add the user-defined conversion step. Any cv-qualification conversion is
4782  // subsumed by the initialization. Per DR5, the created temporary is of the
4783  // cv-unqualified type of the destination.
4784  Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4785  DestType.getUnqualifiedType(),
4786  HadMultipleCandidates);
4787 
4788  // C++14 and before:
4789  // - if the function is a constructor, the call initializes a temporary
4790  // of the cv-unqualified version of the destination type. The [...]
4791  // temporary [...] is then used to direct-initialize, according to the
4792  // rules above, the object that is the destination of the
4793  // copy-initialization.
4794  // Note that this just performs a simple object copy from the temporary.
4795  //
4796  // C++1z:
4797  // - if the function is a constructor, the call is a prvalue of the
4798  // cv-unqualified version of the destination type whose return object
4799  // is initialized by the constructor. The call is used to
4800  // direct-initialize, according to the rules above, the object that
4801  // is the destination of the copy-initialization.
4802  // Therefore we need to do nothing further.
4803  //
4804  // FIXME: Mark this copy as extraneous.
4805  if (!S.getLangOpts().CPlusPlus1z)
4806  Sequence.AddFinalCopy(DestType);
4807  else if (DestType.hasQualifiers())
4808  Sequence.AddQualificationConversionStep(DestType, VK_RValue);
4809  return;
4810  }
4811 
4812  // Add the user-defined conversion step that calls the conversion function.
4813  QualType ConvType = Function->getCallResultType();
4814  Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
4815  HadMultipleCandidates);
4816 
4817  if (ConvType->getAs<RecordType>()) {
4818  // The call is used to direct-initialize [...] the object that is the
4819  // destination of the copy-initialization.
4820  //
4821  // In C++1z, this does not call a constructor if we enter /17.6.1:
4822  // - If the initializer expression is a prvalue and the cv-unqualified
4823  // version of the source type is the same as the class of the
4824  // destination [... do not make an extra copy]
4825  //
4826  // FIXME: Mark this copy as extraneous.
4827  if (!S.getLangOpts().CPlusPlus1z ||
4828  Function->getReturnType()->isReferenceType() ||
4829  !S.Context.hasSameUnqualifiedType(ConvType, DestType))
4830  Sequence.AddFinalCopy(DestType);
4831  else if (!S.Context.hasSameType(ConvType, DestType))
4832  Sequence.AddQualificationConversionStep(DestType, VK_RValue);
4833  return;
4834  }
4835 
4836  // If the conversion following the call to the conversion function
4837  // is interesting, add it as a separate step.
4838  if (Best->FinalConversion.First || Best->FinalConversion.Second ||
4839  Best->FinalConversion.Third) {
4841  ICS.setStandard();
4842  ICS.Standard = Best->FinalConversion;
4843  Sequence.AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
4844  }
4845 }
4846 
4847 /// An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>,
4848 /// a function with a pointer return type contains a 'return false;' statement.
4849 /// In C++11, 'false' is not a null pointer, so this breaks the build of any
4850 /// code using that header.
4851 ///
4852 /// Work around this by treating 'return false;' as zero-initializing the result
4853 /// if it's used in a pointer-returning function in a system header.
4855  const InitializedEntity &Entity,
4856  const Expr *Init) {
4857  return S.getLangOpts().CPlusPlus11 &&
4858  Entity.getKind() == InitializedEntity::EK_Result &&
4859  Entity.getType()->isPointerType() &&
4860  isa<CXXBoolLiteralExpr>(Init) &&
4861  !cast<CXXBoolLiteralExpr>(Init)->getValue() &&
4863 }
4864 
4865 /// The non-zero enum values here are indexes into diagnostic alternatives.
4867 
4868 /// Determines whether this expression is an acceptable ICR source.
4870  bool isAddressOf, bool &isWeakAccess) {
4871  // Skip parens.
4872  e = e->IgnoreParens();
4873 
4874  // Skip address-of nodes.
4875  if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
4876  if (op->getOpcode() == UO_AddrOf)
4877  return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
4878  isWeakAccess);
4879 
4880  // Skip certain casts.
4881  } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
4882  switch (ce->getCastKind()) {
4883  case CK_Dependent:
4884  case CK_BitCast:
4885  case CK_LValueBitCast:
4886  case CK_NoOp:
4887  return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
4888 
4889  case CK_ArrayToPointerDecay:
4890  return IIK_nonscalar;
4891 
4892  case CK_NullToPointer:
4893  return IIK_okay;
4894 
4895  default:
4896  break;
4897  }
4898 
4899  // If we have a declaration reference, it had better be a local variable.
4900  } else if (isa<DeclRefExpr>(e)) {
4901  // set isWeakAccess to true, to mean that there will be an implicit
4902  // load which requires a cleanup.
4904  isWeakAccess = true;
4905 
4906  if (!isAddressOf) return IIK_nonlocal;
4907 
4908  VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
4909  if (!var) return IIK_nonlocal;
4910 
4911  return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
4912 
4913  // If we have a conditional operator, check both sides.
4914  } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
4915  if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
4916  isWeakAccess))
4917  return iik;
4918 
4919  return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
4920 
4921  // These are never scalar.
4922  } else if (isa<ArraySubscriptExpr>(e)) {
4923  return IIK_nonscalar;
4924 
4925  // Otherwise, it needs to be a null pointer constant.
4926  } else {
4928  ? IIK_okay : IIK_nonlocal);
4929  }
4930 
4931  return IIK_nonlocal;
4932 }
4933 
4934 /// Check whether the given expression is a valid operand for an
4935 /// indirect copy/restore.
4937  assert(src->isRValue());
4938  bool isWeakAccess = false;
4939  InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
4940  // If isWeakAccess to true, there will be an implicit
4941  // load which requires a cleanup.
4942  if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
4943  S.Cleanup.setExprNeedsCleanups(true);
4944 
4945  if (iik == IIK_okay) return;
4946 
4947  S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
4948  << ((unsigned) iik - 1) // shift index into diagnostic explanations
4949  << src->getSourceRange();
4950 }
4951 
4952 /// \brief Determine whether we have compatible array types for the
4953 /// purposes of GNU by-copy array initialization.
4954 static bool hasCompatibleArrayTypes(ASTContext &Context, const ArrayType *Dest,
4955  const ArrayType *Source) {
4956  // If the source and destination array types are equivalent, we're
4957  // done.
4958  if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
4959  return true;
4960 
4961  // Make sure that the element types are the same.
4962  if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
4963  return false;
4964 
4965  // The only mismatch we allow is when the destination is an
4966  // incomplete array type and the source is a constant array type.
4967  return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
4968 }
4969 
4971  InitializationSequence &Sequence,
4972  const InitializedEntity &Entity,
4973  Expr *Initializer) {
4974  bool ArrayDecay = false;
4975  QualType ArgType = Initializer->getType();
4976  QualType ArgPointee;
4977  if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
4978  ArrayDecay = true;
4979  ArgPointee = ArgArrayType->getElementType();
4980  ArgType = S.Context.getPointerType(ArgPointee);
4981  }
4982 
4983  // Handle write-back conversion.
4984  QualType ConvertedArgType;
4985  if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
4986  ConvertedArgType))
4987  return false;
4988 
4989  // We should copy unless we're passing to an argument explicitly
4990  // marked 'out'.
4991  bool ShouldCopy = true;
4992  if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4993  ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4994 
4995  // Do we need an lvalue conversion?
4996  if (ArrayDecay || Initializer->isGLValue()) {
4998  ICS.setStandard();
5000 
5001  QualType ResultType;
5002  if (ArrayDecay) {
5004  ResultType = S.Context.getPointerType(ArgPointee);
5005  } else {
5007  ResultType = Initializer->getType().getNonLValueExprType(S.Context);
5008  }
5009 
5010  Sequence.AddConversionSequenceStep(ICS, ResultType);
5011  }
5012 
5013  Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
5014  return true;
5015 }
5016 
5018  InitializationSequence &Sequence,
5019  QualType DestType,
5020  Expr *Initializer) {
5021  if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
5022  (!Initializer->isIntegerConstantExpr(S.Context) &&
5023  !Initializer->getType()->isSamplerT()))
5024  return false;
5025 
5026  Sequence.AddOCLSamplerInitStep(DestType);
5027  return true;
5028 }
5029 
5030 //
5031 // OpenCL 1.2 spec, s6.12.10
5032 //
5033 // The event argument can also be used to associate the
5034 // async_work_group_copy with a previous async copy allowing
5035 // an event to be shared by multiple async copies; otherwise
5036 // event should be zero.
5037 //
5039  InitializationSequence &Sequence,
5040  QualType DestType,
5041  Expr *Initializer) {
5042  if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
5043  !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
5044  (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
5045  return false;
5046 
5047  Sequence.AddOCLZeroEventStep(DestType);
5048  return true;
5049 }
5050 
5052  InitializationSequence &Sequence,
5053  QualType DestType,
5054  Expr *Initializer) {
5055  if (!S.getLangOpts().OpenCL || S.getLangOpts().OpenCLVersion < 200 ||
5056  !DestType->isQueueT() ||
5057  !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
5058  (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
5059  return false;
5060 
5061  Sequence.AddOCLZeroQueueStep(DestType);
5062  return true;
5063 }
5064 
5066  const InitializedEntity &Entity,
5067  const InitializationKind &Kind,
5068  MultiExprArg Args,
5069  bool TopLevelOfInitList,
5070  bool TreatUnavailableAsInvalid)
5071  : FailedCandidateSet(Kind.getLocation(), OverloadCandidateSet::CSK_Normal) {
5072  InitializeFrom(S, Entity, Kind, Args, TopLevelOfInitList,
5073  TreatUnavailableAsInvalid);
5074 }
5075 
5076 /// Tries to get a FunctionDecl out of `E`. If it succeeds and we can take the
5077 /// address of that function, this returns true. Otherwise, it returns false.
5078 static bool isExprAnUnaddressableFunction(Sema &S, const Expr *E) {
5079  auto *DRE = dyn_cast<DeclRefExpr>(E);
5080  if (!DRE || !isa<FunctionDecl>(DRE->getDecl()))
5081  return false;
5082 
5084  cast<FunctionDecl>(DRE->getDecl()));
5085 }
5086 
5087 /// Determine whether we can perform an elementwise array copy for this kind
5088 /// of entity.
5089 static bool canPerformArrayCopy(const InitializedEntity &Entity) {
5090  switch (Entity.getKind()) {
5092  // C++ [expr.prim.lambda]p24:
5093  // For array members, the array elements are direct-initialized in
5094  // increasing subscript order.
5095  return true;
5096 
5098  // C++ [dcl.decomp]p1:
5099  // [...] each element is copy-initialized or direct-initialized from the
5100  // corresponding element of the assignment-expression [...]
5101  return isa<DecompositionDecl>(Entity.getDecl());
5102 
5104  // C++ [class.copy.ctor]p14:
5105  // - if the member is an array, each element is direct-initialized with
5106  // the corresponding subobject of x
5107  return Entity.isImplicitMemberInitializer();
5108 
5110  // All the above cases are intended to apply recursively, even though none
5111  // of them actually say that.
5112  if (auto *E = Entity.getParent())
5113  return canPerformArrayCopy(*E);
5114  break;
5115 
5116  default:
5117  break;
5118  }
5119 
5120  return false;
5121 }
5122 
5124  const InitializedEntity &Entity,
5125  const InitializationKind &Kind,
5126  MultiExprArg Args,
5127  bool TopLevelOfInitList,
5128  bool TreatUnavailableAsInvalid) {
5129  ASTContext &Context = S.Context;
5130 
5131  // Eliminate non-overload placeholder types in the arguments. We
5132  // need to do this before checking whether types are dependent
5133  // because lowering a pseudo-object expression might well give us
5134  // something of dependent type.
5135  for (unsigned I = 0, E = Args.size(); I != E; ++I)
5136  if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
5137  // FIXME: should we be doing this here?
5138  ExprResult result = S.CheckPlaceholderExpr(Args[I]);
5139  if (result.isInvalid()) {
5141  return;
5142  }
5143  Args[I] = result.get();
5144  }
5145 
5146  // C++0x [dcl.init]p16:
5147  // The semantics of initializers are as follows. The destination type is
5148  // the type of the object or reference being initialized and the source
5149  // type is the type of the initializer expression. The source type is not
5150  // defined when the initializer is a braced-init-list or when it is a
5151  // parenthesized list of expressions.
5152  QualType DestType = Entity.getType();
5153 
5154  if (DestType->isDependentType() ||
5157  return;
5158  }
5159 
5160  // Almost everything is a normal sequence.
5162 
5163  QualType SourceType;
5164  Expr *Initializer = nullptr;
5165  if (Args.size() == 1) {
5166  Initializer = Args[0];
5167  if (S.getLangOpts().ObjC1) {
5168  if (S.CheckObjCBridgeRelatedConversions(Initializer->getLocStart(),
5169  DestType, Initializer->getType(),
5170  Initializer) ||
5171  S.ConversionToObjCStringLiteralCheck(DestType, Initializer))
5172  Args[0] = Initializer;
5173  }
5174  if (!isa<InitListExpr>(Initializer))
5175  SourceType = Initializer->getType();
5176  }
5177 
5178  // - If the initializer is a (non-parenthesized) braced-init-list, the
5179  // object is list-initialized (8.5.4).
5180  if (Kind.getKind() != InitializationKind::IK_Direct) {
5181  if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
5182  TryListInitialization(S, Entity, Kind, InitList, *this,
5183  TreatUnavailableAsInvalid);
5184  return;
5185  }
5186  }
5187 
5188  // - If the destination type is a reference type, see 8.5.3.
5189  if (DestType->isReferenceType()) {
5190  // C++0x [dcl.init.ref]p1:
5191  // A variable declared to be a T& or T&&, that is, "reference to type T"
5192  // (8.3.2), shall be initialized by an object, or function, of type T or
5193  // by an object that can be converted into a T.
5194  // (Therefore, multiple arguments are not permitted.)
5195  if (Args.size() != 1)
5197  // C++17 [dcl.init.ref]p5:
5198  // A reference [...] is initialized by an expression [...] as follows:
5199  // If the initializer is not an expression, presumably we should reject,
5200  // but the standard fails to actually say so.
5201  else if (isa<InitListExpr>(Args[0]))
5203  else
5204  TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
5205  return;
5206  }
5207 
5208  // - If the initializer is (), the object is value-initialized.
5209  if (Kind.getKind() == InitializationKind::IK_Value ||
5210  (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
5211  TryValueInitialization(S, Entity, Kind, *this);
5212  return;
5213  }
5214 
5215  // Handle default initialization.
5216  if (Kind.getKind() == InitializationKind::IK_Default) {
5217  TryDefaultInitialization(S, Entity, Kind, *this);
5218  return;
5219  }
5220 
5221  // - If the destination type is an array of characters, an array of
5222  // char16_t, an array of char32_t, or an array of wchar_t, and the
5223  // initializer is a string literal, see 8.5.2.
5224  // - Otherwise, if the destination type is an array, the program is
5225  // ill-formed.
5226  if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
5227  if (Initializer && isa<VariableArrayType>(DestAT)) {
5229  return;
5230  }
5231 
5232  if (Initializer) {
5233  switch (IsStringInit(Initializer, DestAT, Context)) {
5234  case SIF_None:
5235  TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
5236  return;
5239  return;
5242  return;
5245  return;
5246  case SIF_Other:
5247  break;
5248  }
5249  }
5250 
5251  // Some kinds of initialization permit an array to be initialized from
5252  // another array of the same type, and perform elementwise initialization.
5253  if (Initializer && isa<ConstantArrayType>(DestAT) &&
5254  S.Context.hasSameUnqualifiedType(Initializer->getType(),
5255  Entity.getType()) &&
5256  canPerformArrayCopy(Entity)) {
5257  // If source is a prvalue, use it directly.
5258  if (Initializer->getValueKind() == VK_RValue) {
5259  AddArrayInitStep(DestType, /*IsGNUExtension*/false);
5260  return;
5261  }
5262 
5263  // Emit element-at-a-time copy loop.
5264  InitializedEntity Element =
5266  QualType InitEltT =
5267  Context.getAsArrayType(Initializer->getType())->getElementType();
5268  OpaqueValueExpr OVE(Initializer->getExprLoc(), InitEltT,
5269  Initializer->getValueKind(),
5270  Initializer->getObjectKind());
5271  Expr *OVEAsExpr = &OVE;
5272  InitializeFrom(S, Element, Kind, OVEAsExpr, TopLevelOfInitList,
5273  TreatUnavailableAsInvalid);
5274  if (!Failed())
5275  AddArrayInitLoopStep(Entity.getType(), InitEltT);
5276  return;
5277  }
5278 
5279  // Note: as an GNU C extension, we allow initialization of an
5280  // array from a compound literal that creates an array of the same
5281  // type, so long as the initializer has no side effects.
5282  if (!S.getLangOpts().CPlusPlus && Initializer &&
5283  isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
5284  Initializer->getType()->isArrayType()) {
5285  const ArrayType *SourceAT
5286  = Context.getAsArrayType(Initializer->getType());
5287  if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
5289  else if (Initializer->HasSideEffects(S.Context))
5291  else {
5292  AddArrayInitStep(DestType, /*IsGNUExtension*/true);
5293  }
5294  }
5295  // Note: as a GNU C++ extension, we allow list-initialization of a
5296  // class member of array type from a parenthesized initializer list.
5297  else if (S.getLangOpts().CPlusPlus &&
5298  Entity.getKind() == InitializedEntity::EK_Member &&
5299  Initializer && isa<InitListExpr>(Initializer)) {
5300  TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
5301  *this, TreatUnavailableAsInvalid);
5303  } else if (DestAT->getElementType()->isCharType())
5305  else if (IsWideCharCompatible(DestAT->getElementType(), Context))
5307  else
5309 
5310  return;
5311  }
5312 
5313  // Determine whether we should consider writeback conversions for
5314  // Objective-C ARC.
5315  bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
5316  Entity.isParameterKind();
5317 
5318  // We're at the end of the line for C: it's either a write-back conversion
5319  // or it's a C assignment. There's no need to check anything else.
5320  if (!S.getLangOpts().CPlusPlus) {
5321  // If allowed, check whether this is an Objective-C writeback conversion.
5322  if (allowObjCWritebackConversion &&
5323  tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
5324  return;
5325  }
5326 
5327  if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
5328  return;
5329 
5330  if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
5331  return;
5332 
5333  if (TryOCLZeroQueueInitialization(S, *this, DestType, Initializer))
5334  return;
5335 
5336  // Handle initialization in C
5337  AddCAssignmentStep(DestType);
5338  MaybeProduceObjCObject(S, *this, Entity);
5339  return;
5340  }
5341 
5342  assert(S.getLangOpts().CPlusPlus);
5343 
5344  // - If the destination type is a (possibly cv-qualified) class type:
5345  if (DestType->isRecordType()) {
5346  // - If the initialization is direct-initialization, or if it is
5347  // copy-initialization where the cv-unqualified version of the
5348  // source type is the same class as, or a derived class of, the
5349  // class of the destination, constructors are considered. [...]
5350  if (Kind.getKind() == InitializationKind::IK_Direct ||
5351  (Kind.getKind() == InitializationKind::IK_Copy &&
5352  (Context.hasSameUnqualifiedType(SourceType, DestType) ||
5353  S.IsDerivedFrom(Initializer->getLocStart(), SourceType, DestType))))
5354  TryConstructorInitialization(S, Entity, Kind, Args,
5355  DestType, DestType, *this);
5356  // - Otherwise (i.e., for the remaining copy-initialization cases),
5357  // user-defined conversion sequences that can convert from the source
5358  // type to the destination type or (when a conversion function is
5359  // used) to a derived class thereof are enumerated as described in
5360  // 13.3.1.4, and the best one is chosen through overload resolution
5361  // (13.3).
5362  else
5363  TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5364  TopLevelOfInitList);
5365  return;
5366  }
5367 
5368  assert(Args.size() >= 1 && "Zero-argument case handled above");
5369 
5370  // The remaining cases all need a source type.
5371  if (Args.size() > 1) {
5373  return;
5374  } else if (isa<InitListExpr>(Args[0])) {
5376  return;
5377  }
5378 
5379  // - Otherwise, if the source type is a (possibly cv-qualified) class
5380  // type, conversion functions are considered.
5381  if (!SourceType.isNull() && SourceType->isRecordType()) {
5382  // For a conversion to _Atomic(T) from either T or a class type derived
5383  // from T, initialize the T object then convert to _Atomic type.
5384  bool NeedAtomicConversion = false;
5385  if (const AtomicType *Atomic = DestType->getAs<AtomicType>()) {
5386  if (Context.hasSameUnqualifiedType(SourceType, Atomic->getValueType()) ||
5387  S.IsDerivedFrom(Initializer->getLocStart(), SourceType,
5388  Atomic->getValueType())) {
5389  DestType = Atomic->getValueType();
5390  NeedAtomicConversion = true;
5391  }
5392  }
5393 
5394  TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5395  TopLevelOfInitList);
5396  MaybeProduceObjCObject(S, *this, Entity);
5397  if (!Failed() && NeedAtomicConversion)
5398  AddAtomicConversionStep(Entity.getType());
5399  return;
5400  }
5401 
5402  // - Otherwise, the initial value of the object being initialized is the
5403  // (possibly converted) value of the initializer expression. Standard
5404  // conversions (Clause 4) will be used, if necessary, to convert the
5405  // initializer expression to the cv-unqualified version of the
5406  // destination type; no user-defined conversions are considered.
5407 
5409  = S.TryImplicitConversion(Initializer, DestType,
5410  /*SuppressUserConversions*/true,
5411  /*AllowExplicitConversions*/ false,
5412  /*InOverloadResolution*/ false,
5413  /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
5414  allowObjCWritebackConversion);
5415 
5416  if (ICS.isStandard() &&
5418  // Objective-C ARC writeback conversion.
5419 
5420  // We should copy unless we're passing to an argument explicitly
5421  // marked 'out'.
5422  bool ShouldCopy = true;
5423  if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
5424  ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
5425 
5426  // If there was an lvalue adjustment, add it as a separate conversion.
5427  if (ICS.Standard.First == ICK_Array_To_Pointer ||
5429  ImplicitConversionSequence LvalueICS;
5430  LvalueICS.setStandard();
5431  LvalueICS.Standard.setAsIdentityConversion();
5432  LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0));
5433  LvalueICS.Standard.First = ICS.Standard.First;
5434  AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0));
5435  }
5436 
5437  AddPassByIndirectCopyRestoreStep(DestType, ShouldCopy);
5438  } else if (ICS.isBad()) {
5439  DeclAccessPair dap;
5440  if (isLibstdcxxPointerReturnFalseHack(S, Entity, Initializer)) {
5442  } else if (Initializer->getType() == Context.OverloadTy &&
5443  !S.ResolveAddressOfOverloadedFunction(Initializer, DestType,
5444  false, dap))
5446  else if (Initializer->getType()->isFunctionType() &&
5447  isExprAnUnaddressableFunction(S, Initializer))
5449  else
5451  } else {
5452  AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
5453 
5454  MaybeProduceObjCObject(S, *this, Entity);
5455  }
5456 }
5457 
5459  for (auto &S : Steps)
5460  S.Destroy();
5461 }
5462 
5463 //===----------------------------------------------------------------------===//
5464 // Perform initialization
5465 //===----------------------------------------------------------------------===//
5467 getAssignmentAction(const InitializedEntity &Entity, bool Diagnose = false) {
5468  switch(Entity.getKind()) {
5474  return Sema::AA_Initializing;
5475 
5477  if (Entity.getDecl() &&
5478  isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
5479  return Sema::AA_Sending;
5480 
5481  return Sema::AA_Passing;
5482 
5484  if (Entity.getDecl() &&
5485  isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
5486  return Sema::AA_Sending;
5487 
5488  return !Diagnose ? Sema::AA_Passing : Sema::AA_Passing_CFAudited;
5489 
5491  return Sema::AA_Returning;
5492 
5495  // FIXME: Can we tell apart casting vs. converting?
5496  return Sema::AA_Casting;
5497 
5507  return Sema::AA_Initializing;
5508  }
5509 
5510  llvm_unreachable("Invalid EntityKind!");
5511 }
5512 
5513 /// \brief Whether we should bind a created object as a temporary when
5514 /// initializing the given entity.
5515 static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
5516  switch (Entity.getKind()) {
5531  return false;
5532 
5538  return true;
5539  }
5540 
5541  llvm_unreachable("missed an InitializedEntity kind?");
5542 }
5543 
5544 /// \brief Whether the given entity, when initialized with an object
5545 /// created for that initialization, requires destruction.
5546 static bool shouldDestroyEntity(const InitializedEntity &Entity) {
5547  switch (Entity.getKind()) {
5557  return false;
5558 
5569  return true;
5570  }
5571 
5572  llvm_unreachable("missed an InitializedEntity kind?");
5573 }
5574 
5575 /// \brief Get the location at which initialization diagnostics should appear.
5577  Expr *Initializer) {
5578  switch (Entity.getKind()) {
5580  return Entity.getReturnLoc();
5581 
5583  return Entity.getThrowLoc();
5584 
5587  return Entity.getDecl()->getLocation();
5588 
5590  return Entity.getCaptureLoc();
5591 
5606  return Initializer->getLocStart();
5607  }
5608  llvm_unreachable("missed an InitializedEntity kind?");
5609 }
5610 
5611 /// \brief Make a (potentially elidable) temporary copy of the object
5612 /// provided by the given initializer by calling the appropriate copy
5613 /// constructor.
5614 ///
5615 /// \param S The Sema object used for type-checking.
5616 ///
5617 /// \param T The type of the temporary object, which must either be
5618 /// the type of the initializer expression or a superclass thereof.
5619 ///
5620 /// \param Entity The entity being initialized.
5621 ///
5622 /// \param CurInit The initializer expression.
5623 ///
5624 /// \param IsExtraneousCopy Whether this is an "extraneous" copy that
5625 /// is permitted in C++03 (but not C++0x) when binding a reference to
5626 /// an rvalue.
5627 ///
5628 /// \returns An expression that copies the initializer expression into
5629 /// a temporary object, or an error expression if a copy could not be
5630 /// created.
5632  QualType T,
5633  const InitializedEntity &Entity,
5634  ExprResult CurInit,
5635  bool IsExtraneousCopy) {
5636  if (CurInit.isInvalid())
5637  return CurInit;
5638  // Determine which class type we're copying to.
5639  Expr *CurInitExpr = (Expr *)CurInit.get();
5640  CXXRecordDecl *Class = nullptr;
5641  if (const RecordType *Record = T->getAs<RecordType>())
5642  Class = cast<CXXRecordDecl>(Record->getDecl());
5643  if (!Class)
5644  return CurInit;
5645 
5646  SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
5647 
5648  // Make sure that the type we are copying is complete.
5649  if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
5650  return CurInit;
5651 
5652  // Perform overload resolution using the class's constructors. Per
5653  // C++11 [dcl.init]p16, second bullet for class types, this initialization
5654  // is direct-initialization.
5657 
5660  S, Loc, CurInitExpr, CandidateSet, Ctors, Best,
5661  /*CopyInitializing=*/false, /*AllowExplicit=*/true,
5662  /*OnlyListConstructors=*/false, /*IsListInit=*/false,
5663  /*SecondStepOfCopyInit=*/true)) {
5664  case OR_Success:
5665  break;
5666 
5667  case OR_No_Viable_Function:
5668  S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
5669  ? diag::ext_rvalue_to_reference_temp_copy_no_viable
5670  : diag::err_temp_copy_no_viable)
5671  << (int)Entity.getKind() << CurInitExpr->getType()
5672  << CurInitExpr->getSourceRange();
5673  CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5674  if (!IsExtraneousCopy || S.isSFINAEContext())
5675  return ExprError();
5676  return CurInit;
5677 
5678  case OR_Ambiguous:
5679  S.Diag(Loc, diag::err_temp_copy_ambiguous)
5680  << (int)Entity.getKind() << CurInitExpr->getType()
5681  << CurInitExpr->getSourceRange();
5682  CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5683  return ExprError();
5684 
5685  case OR_Deleted:
5686  S.Diag(Loc, diag::err_temp_copy_deleted)
5687  << (int)Entity.getKind() << CurInitExpr->getType()
5688  << CurInitExpr->getSourceRange();
5689  S.NoteDeletedFunction(Best->Function);
5690  return ExprError();
5691  }
5692 
5693  bool HadMultipleCandidates = CandidateSet.size() > 1;
5694 
5695  CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
5696  SmallVector<Expr*, 8> ConstructorArgs;
5697  CurInit.get(); // Ownership transferred into MultiExprArg, below.
5698 
5699  S.CheckConstructorAccess(Loc, Constructor, Best->FoundDecl, Entity,
5700  IsExtraneousCopy);
5701 
5702  if (IsExtraneousCopy) {
5703  // If this is a totally extraneous copy for C++03 reference
5704  // binding purposes, just return the original initialization
5705  // expression. We don't generate an (elided) copy operation here
5706  // because doing so would require us to pass down a flag to avoid
5707  // infinite recursion, where each step adds another extraneous,
5708  // elidable copy.
5709 
5710  // Instantiate the default arguments of any extra parameters in
5711  // the selected copy constructor, as if we were going to create a
5712  // proper call to the copy constructor.
5713  for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
5714  ParmVarDecl *Parm = Constructor->getParamDecl(I);
5715  if (S.RequireCompleteType(Loc, Parm->getType(),
5716  diag::err_call_incomplete_argument))
5717  break;
5718 
5719  // Build the default argument expression; we don't actually care
5720  // if this succeeds or not, because this routine will complain
5721  // if there was a problem.
5722  S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
5723  }
5724 
5725  return CurInitExpr;
5726  }
5727 
5728  // Determine the arguments required to actually perform the
5729  // constructor call (we might have derived-to-base conversions, or
5730  // the copy constructor may have default arguments).
5731  if (S.CompleteConstructorCall(Constructor, CurInitExpr, Loc, ConstructorArgs))
5732  return ExprError();
5733 
5734  // C++0x [class.copy]p32:
5735  // When certain criteria are met, an implementation is allowed to
5736  // omit the copy/move construction of a class object, even if the
5737  // copy/move constructor and/or destructor for the object have
5738  // side effects. [...]
5739  // - when a temporary class object that has not been bound to a
5740  // reference (12.2) would be copied/moved to a class object
5741  // with the same cv-unqualified type, the copy/move operation
5742  // can be omitted by constructing the temporary object
5743  // directly into the target of the omitted copy/move
5744  //
5745  // Note that the other three bullets are handled elsewhere. Copy
5746  // elision for return statements and throw expressions are handled as part
5747  // of constructor initialization, while copy elision for exception handlers
5748  // is handled by the run-time.
5749  //
5750  // FIXME: If the function parameter is not the same type as the temporary, we
5751  // should still be able to elide the copy, but we don't have a way to
5752  // represent in the AST how much should be elided in this case.
5753  bool Elidable =
5754  CurInitExpr->isTemporaryObject(S.Context, Class) &&
5756  Best->Function->getParamDecl(0)->getType().getNonReferenceType(),
5757  CurInitExpr->getType());
5758 
5759  // Actually perform the constructor call.
5760  CurInit = S.BuildCXXConstructExpr(Loc, T, Best->FoundDecl, Constructor,
5761  Elidable,
5762  ConstructorArgs,
5763  HadMultipleCandidates,
5764  /*ListInit*/ false,
5765  /*StdInitListInit*/ false,
5766  /*ZeroInit*/ false,
5768  SourceRange());
5769 
5770  // If we're supposed to bind temporaries, do so.
5771  if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
5772  CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
5773  return CurInit;
5774 }
5775 
5776 /// \brief Check whether elidable copy construction for binding a reference to
5777 /// a temporary would have succeeded if we were building in C++98 mode, for
5778 /// -Wc++98-compat.
5780  const InitializedEntity &Entity,
5781  Expr *CurInitExpr) {
5782  assert(S.getLangOpts().CPlusPlus11);
5783 
5784  const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>();
5785  if (!Record)
5786  return;
5787 
5788  SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr);
5789  if (S.Diags.isIgnored(diag::warn_cxx98_compat_temp_copy, Loc))
5790  return;
5791 
5792  // Find constructors which would have been considered.
5795  S.LookupConstructors(cast<CXXRecordDecl>(Record->getDecl()));
5796 
5797  // Perform overload resolution.
5800  S, Loc, CurInitExpr, CandidateSet, Ctors, Best,
5801  /*CopyInitializing=*/false, /*AllowExplicit=*/true,
5802  /*OnlyListConstructors=*/false, /*IsListInit=*/false,
5803  /*SecondStepOfCopyInit=*/true);
5804 
5805  PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy)
5806  << OR << (int)Entity.getKind() << CurInitExpr->getType()
5807  << CurInitExpr->getSourceRange();
5808 
5809  switch (OR) {
5810  case OR_Success:
5811  S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
5812  Best->FoundDecl, Entity, Diag);
5813  // FIXME: Check default arguments as far as that's possible.
5814  break;
5815 
5816  case OR_No_Viable_Function:
5817  S.Diag(Loc, Diag);
5818  CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5819  break;
5820 
5821  case OR_Ambiguous:
5822  S.Diag(Loc, Diag);
5823  CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5824  break;
5825 
5826  case OR_Deleted:
5827  S.Diag(Loc, Diag);
5828  S.NoteDeletedFunction(Best->Function);
5829  break;
5830  }
5831 }
5832 
5833 void InitializationSequence::PrintInitLocationNote(Sema &S,
5834  const InitializedEntity &Entity) {
5835  if (Entity.isParameterKind() && Entity.getDecl()) {
5836  if (Entity.getDecl()->getLocation().isInvalid())
5837  return;
5838 
5839  if (Entity.getDecl()->getDeclName())
5840  S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
5841  << Entity.getDecl()->getDeclName();
5842  else
5843  S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
5844  }
5845  else if (Entity.getKind() == InitializedEntity::EK_RelatedResult &&
5846  Entity.getMethodDecl())
5847  S.Diag(Entity.getMethodDecl()->getLocation(),
5848  diag::note_method_return_type_change)
5849  << Entity.getMethodDecl()->getDeclName();
5850 }
5851 
5852 /// Returns true if the parameters describe a constructor initialization of
5853 /// an explicit temporary object, e.g. "Point(x, y)".
5854 static bool isExplicitTemporary(const InitializedEntity &Entity,
5855  const InitializationKind &Kind,
5856  unsigned NumArgs) {
5857  switch (Entity.getKind()) {
5861  break;
5862  default:
5863  return false;
5864  }
5865 
5866  switch (Kind.getKind()) {
5868  return true;
5869  // FIXME: Hack to work around cast weirdness.
5872  return NumArgs != 1;
5873  default:
5874  return false;
5875  }
5876 }
5877 
5878 static ExprResult
5880  const InitializedEntity &Entity,
5881  const InitializationKind &Kind,
5882  MultiExprArg Args,
5884  bool &ConstructorInitRequiresZeroInit,
5885  bool IsListInitialization,
5886  bool IsStdInitListInitialization,
5887  SourceLocation LBraceLoc,
5888  SourceLocation RBraceLoc) {
5889  unsigned NumArgs = Args.size();
5890  CXXConstructorDecl *Constructor
5891  = cast<CXXConstructorDecl>(Step.Function.Function);
5892  bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
5893 
5894  // Build a call to the selected constructor.
5895  SmallVector<Expr*, 8> ConstructorArgs;
5896  SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
5897  ? Kind.getEqualLoc()
5898  : Kind.getLocation();
5899 
5900  if (Kind.getKind() == InitializationKind::IK_Default) {
5901  // Force even a trivial, implicit default constructor to be
5902  // semantically checked. We do this explicitly because we don't build
5903  // the definition for completely trivial constructors.
5904  assert(Constructor->getParent() && "No parent class for constructor.");
5905  if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
5906  Constructor->isTrivial() && !Constructor->isUsed(false))
5907  S.DefineImplicitDefaultConstructor(Loc, Constructor);
5908  }
5909 
5910  ExprResult CurInit((Expr *)nullptr);
5911 
5912  // C++ [over.match.copy]p1:
5913  // - When initializing a temporary to be bound to the first parameter
5914  // of a constructor that takes a reference to possibly cv-qualified
5915  // T as its first argument, called with a single argument in the
5916  // context of direct-initialization, explicit conversion functions
5917  // are also considered.
5918  bool AllowExplicitConv =
5919  Kind.AllowExplicit() && !Kind.isCopyInit() && Args.size() == 1 &&
5922 
5923  // Determine the arguments required to actually perform the constructor
5924  // call.
5925  if (S.CompleteConstructorCall(Constructor, Args,
5926  Loc, ConstructorArgs,
5927  AllowExplicitConv,
5928  IsListInitialization))
5929  return ExprError();
5930 
5931 
5932  if (isExplicitTemporary(Entity, Kind, NumArgs)) {
5933  // An explicitly-constructed temporary, e.g., X(1, 2).
5934  if (S.DiagnoseUseOfDecl(Constructor, Loc))
5935  return ExprError();
5936 
5937  TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5938  if (!TSInfo)
5939  TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
5940  SourceRange ParenOrBraceRange =
5942  ? SourceRange(LBraceLoc, RBraceLoc)
5943  : Kind.getParenRange();
5944 
5945  if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(
5946  Step.Function.FoundDecl.getDecl())) {
5947  Constructor = S.findInheritingConstructor(Loc, Constructor, Shadow);
5948  if (S.DiagnoseUseOfDecl(Constructor, Loc))
5949  return ExprError();
5950  }
5951  S.MarkFunctionReferenced(Loc, Constructor);
5952 
5953  CurInit = new (S.Context) CXXTemporaryObjectExpr(
5954  S.Context, Constructor,
5955  Entity.getType().getNonLValueExprType(S.Context), TSInfo,
5956  ConstructorArgs, ParenOrBraceRange, HadMultipleCandidates,
5957  IsListInitialization, IsStdInitListInitialization,
5958  ConstructorInitRequiresZeroInit);
5959  } else {
5960  CXXConstructExpr::ConstructionKind ConstructKind =
5962 
5963  if (Entity.getKind() == InitializedEntity::EK_Base) {
5964  ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
5967  } else if (Entity.getKind() == InitializedEntity::EK_Delegating) {
5968  ConstructKind = CXXConstructExpr::CK_Delegating;
5969  }
5970 
5971  // Only get the parenthesis or brace range if it is a list initialization or
5972  // direct construction.
5973  SourceRange ParenOrBraceRange;
5974  if (IsListInitialization)
5975  ParenOrBraceRange = SourceRange(LBraceLoc, RBraceLoc);
5976  else if (Kind.getKind() == InitializationKind::IK_Direct)
5977  ParenOrBraceRange = Kind.getParenRange();
5978 
5979  // If the entity allows NRVO, mark the construction as elidable
5980  // unconditionally.
5981  if (Entity.allowsNRVO())
5982  CurInit = S.BuildCXXConstructExpr(Loc, Step.Type,
5983  Step.Function.FoundDecl,
5984  Constructor, /*Elidable=*/true,
5985  ConstructorArgs,
5986  HadMultipleCandidates,
5987  IsListInitialization,
5988  IsStdInitListInitialization,
5989  ConstructorInitRequiresZeroInit,
5990  ConstructKind,
5991  ParenOrBraceRange);
5992  else
5993  CurInit = S.BuildCXXConstructExpr(Loc, Step.Type,
5994  Step.Function.FoundDecl,
5995  Constructor,
5996  ConstructorArgs,
5997  HadMultipleCandidates,
5998  IsListInitialization,
5999  IsStdInitListInitialization,
6000  ConstructorInitRequiresZeroInit,
6001  ConstructKind,
6002  ParenOrBraceRange);
6003  }
6004  if (CurInit.isInvalid())
6005  return ExprError();
6006 
6007  // Only check access if all of that succeeded.
6008  S.CheckConstructorAccess(Loc, Constructor, Step.Function.FoundDecl, Entity);
6009  if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc))
6010  return ExprError();
6011 
6012  if (shouldBindAsTemporary(Entity))
6013  CurInit = S.MaybeBindToTemporary(CurInit.get());
6014 
6015  return CurInit;
6016 }
6017 
6018 /// Determine whether the specified InitializedEntity definitely has a lifetime
6019 /// longer than the current full-expression. Conservatively returns false if
6020 /// it's unclear.
6021 static bool
6023  const InitializedEntity *Top = &Entity;
6024  while (Top->getParent())
6025  Top = Top->getParent();
6026 
6027  switch (Top->getKind()) {
6036  return true;
6037 
6043  // Could not determine what the full initialization is. Assume it might not
6044  // outlive the full-expression.
6045  return false;
6046 
6053  // The entity being initialized might not outlive the full-expression.
6054  return false;
6055  }
6056 
6057  llvm_unreachable("unknown entity kind");
6058 }
6059 
6060 /// Determine the declaration which an initialized entity ultimately refers to,
6061 /// for the purpose of lifetime-extending a temporary bound to a reference in
6062 /// the initialization of \p Entity.
6064  const InitializedEntity *Entity,
6065  const InitializedEntity *FallbackDecl = nullptr) {
6066  // C++11 [class.temporary]p5:
6067  switch (Entity->getKind()) {
6069  // The temporary [...] persists for the lifetime of the reference
6070  return Entity;
6071 
6073  // For subobjects, we look at the complete object.
6074  if (Entity->getParent())
6076  Entity);
6077 
6078  // except:
6079  // -- A temporary bound to a reference member in a constructor's
6080  // ctor-initializer persists until the constructor exits.
6081  return Entity;
6082 
6084  // Per [dcl.decomp]p3, the binding is treated as a variable of reference
6085  // type.
6086  return Entity;
6087 
6090  // -- A temporary bound to a reference parameter in a function call
6091  // persists until the completion of the full-expression containing
6092  // the call.
6094  // -- The lifetime of a temporary bound to the returned value in a
6095  // function return statement is not extended; the temporary is
6096  // destroyed at the end of the full-expression in the return statement.
6098  // -- A temporary bound to a reference in a new-initializer persists
6099  // until the completion of the full-expression containing the
6100  // new-initializer.
6101  return nullptr;
6102 
6106  // We don't yet know the storage duration of the surrounding temporary.
6107  // Assume it's got full-expression duration for now, it will patch up our
6108  // storage duration if that's not correct.
6109  return nullptr;
6110 
6112  // For subobjects, we look at the complete object.
6114  FallbackDecl);
6115 
6117  // For subobjects, we look at the complete object.
6118  if (Entity->getParent())
6120  Entity);
6121  // Fall through.
6123  // We can reach this case for aggregate initialization in a constructor:
6124  // struct A { int &&r; };
6125  // struct B : A { B() : A{0} {} };
6126  // In this case, use the innermost field decl as the context.
6127  return FallbackDecl;
6128 
6135  return nullptr;
6136  }
6137  llvm_unreachable("unknown entity kind");
6138 }
6139 
6140 static void performLifetimeExtension(Expr *Init,
6141  const InitializedEntity *ExtendingEntity);
6142 
6143 /// Update a glvalue expression that is used as the initializer of a reference
6144 /// to note that its lifetime is extended.
6145 /// \return \c true if any temporary had its lifetime extended.
6146 static bool
6148  const InitializedEntity *ExtendingEntity) {
6149  // Walk past any constructs which we can lifetime-extend across.
6150  Expr *Old;
6151  do {
6152  Old = Init;
6153 
6154  if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
6155  if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
6156  // This is just redundant braces around an initializer. Step over it.
6157  Init = ILE->getInit(0);
6158  }
6159  }
6160 
6161  // Step over any subobject adjustments; we may have a materialized
6162  // temporary inside them.
6163  Init = const_cast<Expr *>(Init->skipRValueSubobjectAdjustments());
6164 
6165  // Per current approach for DR1376, look through casts to reference type
6166  // when performing lifetime extension.
6167  if (CastExpr *CE = dyn_cast<CastExpr>(Init))
6168  if (CE->getSubExpr()->isGLValue())
6169  Init = CE->getSubExpr();
6170 
6171  // Per the current approach for DR1299, look through array element access
6172  // when performing lifetime extension.
6173  if (auto *ASE = dyn_cast<ArraySubscriptExpr>(Init))
6174  Init = ASE->getBase();
6175  } while (Init != Old);
6176 
6177  if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) {
6178  // Update the storage duration of the materialized temporary.
6179  // FIXME: Rebuild the expression instead of mutating it.
6180  ME->setExtendingDecl(ExtendingEntity->getDecl(),
6181  ExtendingEntity->allocateManglingNumber());
6182  performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingEntity);
6183  return true;
6184  }
6185 
6186  return false;
6187 }
6188 
6189 /// Update a prvalue expression that is going to be materialized as a
6190 /// lifetime-extended temporary.
6191 static void performLifetimeExtension(Expr *Init,
6192  const InitializedEntity *ExtendingEntity) {
6193  // Dig out the expression which constructs the extended temporary.
6194  Init = const_cast<Expr *>(Init->skipRValueSubobjectAdjustments());
6195 
6196  if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init))
6197  Init = BTE->getSubExpr();
6198 
6199  if (CXXStdInitializerListExpr *ILE =
6200  dyn_cast<CXXStdInitializerListExpr>(Init)) {
6201  performReferenceExtension(ILE->getSubExpr(), ExtendingEntity);
6202  return;
6203  }
6204 
6205  if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
6206  if (ILE->getType()->isArrayType()) {
6207  for (unsigned I = 0, N = ILE->getNumInits(); I != N; ++I)
6208  performLifetimeExtension(ILE->getInit(I), ExtendingEntity);
6209  return;
6210  }
6211 
6212  if (CXXRecordDecl *RD = ILE->getType()->getAsCXXRecordDecl()) {
6213  assert(RD->isAggregate() && "aggregate init on non-aggregate");
6214 
6215  // If we lifetime-extend a braced initializer which is initializing an
6216  // aggregate, and that aggregate contains reference members which are
6217  // bound to temporaries, those temporaries are also lifetime-extended.
6218  if (RD->isUnion() && ILE->getInitializedFieldInUnion() &&
6219  ILE->getInitializedFieldInUnion()->getType()->isReferenceType())
6220  performReferenceExtension(ILE->getInit(0), ExtendingEntity);
6221  else {
6222  unsigned Index = 0;
6223  for (const auto *I : RD->fields()) {
6224  if (Index >= ILE->getNumInits())
6225  break;
6226  if (I->isUnnamedBitfield())
6227  continue;
6228  Expr *SubInit = ILE->getInit(Index);
6229  if (I->getType()->isReferenceType())
6230  performReferenceExtension(SubInit, ExtendingEntity);
6231  else if (isa<InitListExpr>(SubInit) ||
6232  isa<CXXStdInitializerListExpr>(SubInit))
6233  // This may be either aggregate-initialization of a member or
6234  // initialization of a std::initializer_list object. Either way,
6235  // we should recursively lifetime-extend that initializer.
6236  performLifetimeExtension(SubInit, ExtendingEntity);
6237  ++Index;
6238  }
6239  }
6240  }
6241  }
6242 }
6243 
6244 static void warnOnLifetimeExtension(Sema &S, const InitializedEntity &Entity,
6245  const Expr *Init, bool IsInitializerList,
6246  const ValueDecl *ExtendingDecl) {
6247  // Warn if a field lifetime-extends a temporary.
6248  if (isa<FieldDecl>(ExtendingDecl)) {
6249  if (IsInitializerList) {
6250  S.Diag(Init->getExprLoc(), diag::warn_dangling_std_initializer_list)
6251  << /*at end of constructor*/true;
6252  return;
6253  }
6254 
6255  bool IsSubobjectMember = false;
6256  for (const InitializedEntity *Ent = Entity.getParent(); Ent;
6257  Ent = Ent->getParent()) {
6258  if (Ent->getKind() != InitializedEntity::EK_Base) {
6259  IsSubobjectMember = true;
6260  break;
6261  }
6262  }
6263  S.Diag(Init->getExprLoc(),
6264  diag::warn_bind_ref_member_to_temporary)
6265  << ExtendingDecl << Init->getSourceRange()
6266  << IsSubobjectMember << IsInitializerList;
6267  if (IsSubobjectMember)
6268  S.Diag(ExtendingDecl->getLocation(),
6269  diag::note_ref_subobject_of_member_declared_here);
6270  else
6271  S.Diag(ExtendingDecl->getLocation(),
6272  diag::note_ref_or_ptr_member_declared_here)
6273  << /*is pointer*/false;
6274  }
6275 }
6276 
6277 static void DiagnoseNarrowingInInitList(Sema &S,
6278  const ImplicitConversionSequence &ICS,
6279  QualType PreNarrowingType,
6280  QualType EntityType,
6281  const Expr *PostInit);
6282 
6283 /// Provide warnings when std::move is used on construction.
6284 static void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr,
6285  bool IsReturnStmt) {
6286  if (!InitExpr)
6287  return;
6288 
6289  if (S.inTemplateInstantiation())
6290  return;
6291 
6292  QualType DestType = InitExpr->getType();
6293  if (!DestType->isRecordType())
6294  return;
6295 
6296  unsigned DiagID = 0;
6297  if (IsReturnStmt) {
6298  const CXXConstructExpr *CCE =
6299  dyn_cast<CXXConstructExpr>(InitExpr->IgnoreParens());
6300  if (!CCE || CCE->getNumArgs() != 1)
6301  return;
6302 
6303  if (!CCE->getConstructor()->isCopyOrMoveConstructor())
6304  return;
6305 
6306  InitExpr = CCE->getArg(0)->IgnoreImpCasts();
6307  }
6308 
6309  // Find the std::move call and get the argument.
6310  const CallExpr *CE = dyn_cast<CallExpr>(InitExpr->IgnoreParens());
6311  if (!CE || CE->getNumArgs() != 1)
6312  return;
6313 
6314  const FunctionDecl *MoveFunction = CE->getDirectCallee();
6315  if (!MoveFunction || !MoveFunction->isInStdNamespace() ||
6316  !MoveFunction->getIdentifier() ||
6317  !MoveFunction->getIdentifier()->isStr("move"))
6318  return;
6319 
6320  const Expr *Arg = CE->getArg(0)->IgnoreImplicit();
6321 
6322  if (IsReturnStmt) {
6323  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts());
6324  if (!DRE || DRE->refersToEnclosingVariableOrCapture())
6325  return;
6326 
6327  const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl());
6328  if (!VD || !VD->hasLocalStorage())
6329  return;
6330 
6331  QualType SourceType = VD->getType();
6332  if (!SourceType->isRecordType())
6333  return;
6334 
6335  if (!S.Context.hasSameUnqualifiedType(DestType, SourceType)) {
6336  return;
6337  }
6338 
6339  // If we're returning a function parameter, copy elision
6340  // is not possible.
6341  if (isa<ParmVarDecl>(VD))
6342  DiagID = diag::warn_redundant_move_on_return;
6343  else
6344  DiagID = diag::warn_pessimizing_move_on_return;
6345  } else {
6346  DiagID = diag::warn_pessimizing_move_on_initialization;
6347  const Expr *ArgStripped = Arg->IgnoreImplicit()->IgnoreParens();
6348  if (!ArgStripped->isRValue() || !ArgStripped->getType()->isRecordType())
6349  return;
6350  }
6351 
6352  S.Diag(CE->getLocStart(), DiagID);
6353 
6354  // Get all the locations for a fix-it. Don't emit the fix-it if any location
6355  // is within a macro.
6356  SourceLocation CallBegin = CE->getCallee()->getLocStart();
6357  if (CallBegin.isMacroID())
6358  return;
6359  SourceLocation RParen = CE->getRParenLoc();
6360  if (RParen.isMacroID())
6361  return;
6362  SourceLocation LParen;
6363  SourceLocation ArgLoc = Arg->getLocStart();
6364 
6365  // Special testing for the argument location. Since the fix-it needs the
6366  // location right before the argument, the argument location can be in a
6367  // macro only if it is at the beginning of the macro.
6368  while (ArgLoc.isMacroID() &&
6370  ArgLoc = S.getSourceManager().getImmediateExpansionRange(ArgLoc).first;
6371  }
6372 
6373  if (LParen.isMacroID())
6374  return;
6375 
6376  LParen = ArgLoc.getLocWithOffset(-1);
6377 
6378  S.Diag(CE->getLocStart(), diag::note_remove_move)
6379  << FixItHint::CreateRemoval(SourceRange(CallBegin, LParen))
6380  << FixItHint::CreateRemoval(SourceRange(RParen, RParen));
6381 }
6382 
6383 static void CheckForNullPointerDereference(Sema &S, const Expr *E) {
6384  // Check to see if we are dereferencing a null pointer. If so, this is
6385  // undefined behavior, so warn about it. This only handles the pattern
6386  // "*null", which is a very syntactic check.
6387  if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts()))
6388  if (UO->getOpcode() == UO_Deref &&
6389  UO->getSubExpr()->IgnoreParenCasts()->
6390  isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull)) {
6391  S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO,
6392  S.PDiag(diag::warn_binding_null_to_reference)
6393  << UO->getSubExpr()->getSourceRange());
6394  }
6395 }
6396 
6399  bool BoundToLvalueReference) {
6400  auto MTE = new (Context)
6401  MaterializeTemporaryExpr(T, Temporary, BoundToLvalueReference);
6402 
6403  // Order an ExprWithCleanups for lifetime marks.
6404  //
6405  // TODO: It'll be good to have a single place to check the access of the
6406  // destructor and generate ExprWithCleanups for various uses. Currently these
6407  // are done in both CreateMaterializeTemporaryExpr and MaybeBindToTemporary,
6408  // but there may be a chance to merge them.
6410  return MTE;
6411 }
6412 
6414  // In C++98, we don't want to implicitly create an xvalue.
6415  // FIXME: This means that AST consumers need to deal with "prvalues" that
6416  // denote materialized temporaries. Maybe we should add another ValueKind
6417  // for "xvalue pretending to be a prvalue" for C++98 support.
6418  if (!E->isRValue() || !getLangOpts().CPlusPlus11)
6419  return E;
6420 
6421  // C++1z [conv.rval]/1: T shall be a complete type.
6422  // FIXME: Does this ever matter (can we form a prvalue of incomplete type)?
6423  // If so, we should check for a non-abstract class type here too.
6424  QualType T = E->getType();
6425  if (RequireCompleteType(E->getExprLoc(), T, diag::err_incomplete_type))
6426  return ExprError();
6427 
6428  return CreateMaterializeTemporaryExpr(E->getType(), E, false);
6429 }
6430 
6431 ExprResult
6433  const InitializedEntity &Entity,
6434  const InitializationKind &Kind,
6435  MultiExprArg Args,
6436  QualType *ResultType) {
6437  if (Failed()) {
6438  Diagnose(S, Entity, Kind, Args);
6439  return ExprError();
6440  }
6441  if (!ZeroInitializationFixit.empty()) {
6442  unsigned DiagID = diag::err_default_init_const;
6443  if (Decl *D = Entity.getDecl())
6444  if (S.getLangOpts().MSVCCompat && D->hasAttr<SelectAnyAttr>())
6445  DiagID = diag::ext_default_init_const;
6446 
6447  // The initialization would have succeeded with this fixit. Since the fixit
6448  // is on the error, we need to build a valid AST in this case, so this isn't
6449  // handled in the Failed() branch above.
6450  QualType DestType = Entity.getType();
6451  S.Diag(Kind.getLocation(), DiagID)
6452  << DestType << (bool)DestType->getAs<RecordType>()
6453  << FixItHint::CreateInsertion(ZeroInitializationFixitLoc,
6454  ZeroInitializationFixit);
6455  }
6456 
6457  if (getKind() == DependentSequence) {
6458  // If the declaration is a non-dependent, incomplete array type
6459  // that has an initializer, then its type will be completed once
6460  // the initializer is instantiated.
6461  if (ResultType && !Entity.getType()->isDependentType() &&
6462  Args.size() == 1) {
6463  QualType DeclType = Entity.getType();
6464  if (const IncompleteArrayType *ArrayT
6465  = S.Context.getAsIncompleteArrayType(DeclType)) {
6466  // FIXME: We don't currently have the ability to accurately
6467  // compute the length of an initializer list without
6468  // performing full type-checking of the initializer list
6469  // (since we have to determine where braces are implicitly
6470  // introduced and such). So, we fall back to making the array
6471  // type a dependently-sized array type with no specified
6472  // bound.
6473  if (isa<InitListExpr>((Expr *)Args[0])) {
6474  SourceRange Brackets;
6475 
6476  // Scavange the location of the brackets from the entity, if we can.
6477  if (auto *DD = dyn_cast_or_null<DeclaratorDecl>(Entity.getDecl())) {
6478  if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
6479  TypeLoc TL = TInfo->getTypeLoc();
6480  if (IncompleteArrayTypeLoc ArrayLoc =
6482  Brackets = ArrayLoc.getBracketsRange();
6483  }
6484  }
6485 
6486  *ResultType
6487  = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
6488  /*NumElts=*/nullptr,
6489  ArrayT->getSizeModifier(),
6490  ArrayT->getIndexTypeCVRQualifiers(),
6491  Brackets);
6492  }
6493 
6494  }
6495  }
6496  if (Kind.getKind() == InitializationKind::IK_Direct &&
6497  !Kind.isExplicitCast()) {
6498  // Rebuild the ParenListExpr.
6499  SourceRange ParenRange = Kind.getParenRange();
6500  return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(),
6501  Args);
6502  }
6503  assert(Kind.getKind() == InitializationKind::IK_Copy ||
6504  Kind.isExplicitCast() ||
6506  return ExprResult(Args[0]);
6507  }
6508 
6509  // No steps means no initialization.
6510  if (Steps.empty())
6511  return ExprResult((Expr *)nullptr);
6512 
6513  if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
6514  Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
6515  !Entity.isParameterKind()) {
6516  // Produce a C++98 compatibility warning if we are initializing a reference
6517  // from an initializer list. For parameters, we produce a better warning
6518  // elsewhere.
6519  Expr *Init = Args[0];
6520  S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
6521  << Init->getSourceRange();
6522  }
6523 
6524  // OpenCL v2.0 s6.13.11.1. atomic variables can be initialized in global scope
6525  QualType ETy = Entity.getType();
6526  Qualifiers TyQualifiers = ETy.getQualifiers();
6527  bool HasGlobalAS = TyQualifiers.hasAddressSpace() &&
6528  TyQualifiers.getAddressSpace() == LangAS::opencl_global;
6529 
6530  if (S.getLangOpts().OpenCLVersion >= 200 &&
6531  ETy->isAtomicType() && !HasGlobalAS &&
6532  Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
6533  S.Diag(Args[0]->getLocStart(), diag::err_opencl_atomic_init) << 1 <<
6534  SourceRange(Entity.getDecl()->getLocStart(), Args[0]->getLocEnd());
6535  return ExprError();
6536  }
6537 
6538  // Diagnose cases where we initialize a pointer to an array temporary, and the
6539  // pointer obviously outlives the temporary.
6540  if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
6541  Entity.getType()->isPointerType() &&
6543  const Expr *Init = Args[0]->skipRValueSubobjectAdjustments();
6544  if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Init))
6545  Init = MTE->GetTemporaryExpr();
6547  if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
6548  S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
6549  << Init->getSourceRange();
6550  }
6551 
6552  QualType DestType = Entity.getType().getNonReferenceType();
6553  // FIXME: Ugly hack around the fact that Entity.getType() is not
6554  // the same as Entity.getDecl()->getType() in cases involving type merging,
6555  // and we want latter when it makes sense.
6556  if (ResultType)
6557  *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
6558  Entity.getType();
6559 
6560  ExprResult CurInit((Expr *)nullptr);
6561  SmallVector<Expr*, 4> ArrayLoopCommonExprs;
6562 
6563  // For initialization steps that start with a single initializer,
6564  // grab the only argument out the Args and place it into the "current"
6565  // initializer.
6566  switch (Steps.front().Kind) {
6571  case SK_BindReference:
6573  case SK_FinalCopy:
6575  case SK_UserConversion:
6579  case SK_AtomicConversion:
6580  case SK_LValueToRValue:
6581  case SK_ConversionSequence:
6583  case SK_ListInitialization:
6584  case SK_UnwrapInitList:
6585  case SK_RewrapInitList:
6586  case SK_CAssignment:
6587  case SK_StringInit:
6589  case SK_ArrayLoopIndex:
6590  case SK_ArrayLoopInit:
6591  case SK_ArrayInit:
6592  case SK_GNUArrayInit:
6596  case SK_ProduceObjCObject:
6597  case SK_StdInitializerList:
6598  case SK_OCLSamplerInit:
6599  case SK_OCLZeroEvent:
6600  case SK_OCLZeroQueue: {
6601  assert(Args.size() == 1);
6602  CurInit = Args[0];
6603  if (!CurInit.get()) return ExprError();
6604  break;
6605  }
6606 
6610  case SK_ZeroInitialization:
6611  break;
6612  }
6613 
6614  // Promote from an unevaluated context to an unevaluated list context in
6615  // C++11 list-initialization; we need to instantiate entities usable in
6616  // constant expressions here in order to perform narrowing checks =(
6619  CurInit.get() && isa<InitListExpr>(CurInit.get()));
6620 
6621  // C++ [class.abstract]p2:
6622  // no objects of an abstract class can be created except as subobjects
6623  // of a class derived from it
6624  auto checkAbstractType = [&](QualType T) -> bool {
6625  if (Entity.getKind() == InitializedEntity::EK_Base ||
6627  return false;
6628  return S.RequireNonAbstractType(Kind.getLocation(), T,
6629  diag::err_allocation_of_abstract_type);
6630  };
6631 
6632  // Walk through the computed steps for the initialization sequence,
6633  // performing the specified conversions along the way.
6634  bool ConstructorInitRequiresZeroInit = false;
6635  for (step_iterator Step = step_begin(), StepEnd = step_end();
6636  Step != StepEnd; ++Step) {
6637  if (CurInit.isInvalid())
6638  return ExprError();
6639 
6640  QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
6641 
6642  switch (Step->Kind) {
6644  // Overload resolution determined which function invoke; update the
6645  // initializer to reflect that choice.
6648  return ExprError();
6649  CurInit = S.FixOverloadedFunctionReference(CurInit,
6652  break;
6653 
6657  // We have a derived-to-base cast that produces either an rvalue or an
6658  // lvalue. Perform that cast.
6659 
6660  CXXCastPath BasePath;
6661 
6662  // Casts to inaccessible base classes are allowed with C-style casts.
6663  bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
6664  if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
6665  CurInit.get()->getLocStart(),
6666  CurInit.get()->getSourceRange(),
6667  &BasePath, IgnoreBaseAccess))
6668  return ExprError();
6669 
6670  ExprValueKind VK =
6672  VK_LValue :
6674  VK_XValue :
6675  VK_RValue);
6676  CurInit =
6677  ImplicitCastExpr::Create(S.Context, Step->Type, CK_DerivedToBase,
6678  CurInit.get(), &BasePath, VK);
6679  break;
6680  }
6681 
6682  case SK_BindReference:
6683  // Reference binding does not have any corresponding ASTs.
6684 
6685  // Check exception specifications
6686  if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
6687  return ExprError();
6688 
6689  // We don't check for e.g. function pointers here, since address
6690  // availability checks should only occur when the function first decays
6691  // into a pointer or reference.
6692  if (CurInit.get()->getType()->isFunctionProtoType()) {
6693  if (auto *DRE = dyn_cast<DeclRefExpr>(CurInit.get()->IgnoreParens())) {
6694  if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
6695  if (!S.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
6696  DRE->getLocStart()))
6697  return ExprError();
6698  }
6699  }
6700  }
6701 
6702  // Even though we didn't materialize a temporary, the binding may still
6703  // extend the lifetime of a temporary. This happens if we bind a reference
6704  // to the result of a cast to reference type.
6705  if (const InitializedEntity *ExtendingEntity =
6707  if (performReferenceExtension(CurInit.get(), ExtendingEntity))
6708  warnOnLifetimeExtension(S, Entity, CurInit.get(),
6709  /*IsInitializerList=*/false,
6710  ExtendingEntity->getDecl());
6711 
6712  CheckForNullPointerDereference(S, CurInit.get());
6713  break;
6714 
6716  // Make sure the "temporary" is actually an rvalue.
6717  assert(CurInit.get()->isRValue() && "not a temporary");
6718 
6719  // Check exception specifications
6720  if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
6721  return ExprError();
6722 
6723  // Materialize the temporary into memory.
6725  Step->Type, CurInit.get(), Entity.getType()->isLValueReferenceType());
6726 
6727  // Maybe lifetime-extend the temporary's subobjects to match the
6728  // entity's lifetime.
6729  if (const InitializedEntity *ExtendingEntity =
6731  if (performReferenceExtension(MTE, ExtendingEntity))
6732  warnOnLifetimeExtension(S, Entity, CurInit.get(),
6733  /*IsInitializerList=*/false,
6734  ExtendingEntity->getDecl());
6735 
6736  // If we're extending this temporary to automatic storage duration -- we
6737  // need to register its cleanup during the full-expression's cleanups.
6738  if (MTE->getStorageDuration() == SD_Automatic &&
6739  MTE->getType().isDestructedType())
6740  S.Cleanup.setExprNeedsCleanups(true);
6741 
6742  CurInit = MTE;
6743  break;
6744  }
6745 
6746  case SK_FinalCopy:
6747  if (checkAbstractType(Step->Type))
6748  return ExprError();
6749 
6750  // If the overall initialization is initializing a temporary, we already
6751  // bound our argument if it was necessary to do so. If not (if we're
6752  // ultimately initializing a non-temporary), our argument needs to be
6753  // bound since it's initializing a function parameter.
6754  // FIXME: This is a mess. Rationalize temporary destruction.
6755  if (!shouldBindAsTemporary(Entity))
6756  CurInit = S.MaybeBindToTemporary(CurInit.get());
6757  CurInit = CopyObject(S, Step->Type, Entity, CurInit,
6758  /*IsExtraneousCopy=*/false);
6759  break;
6760 
6762  CurInit = CopyObject(S, Step->Type, Entity, CurInit,
6763  /*IsExtraneousCopy=*/true);
6764  break;
6765 
6766  case SK_UserConversion: {
6767  // We have a user-defined conversion that invokes either a constructor
6768  // or a conversion function.
6772  bool HadMultipleCandidates = Step->Function.HadMultipleCandidates;
6773  bool CreatedObject = false;
6774  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
6775  // Build a call to the selected constructor.
6776  SmallVector<Expr*, 8> ConstructorArgs;
6777  SourceLocation Loc = CurInit.get()->getLocStart();
6778 
6779  // Determine the arguments required to actually perform the constructor
6780  // call.
6781  Expr *Arg = CurInit.get();
6782  if (S.CompleteConstructorCall(Constructor,
6783  MultiExprArg(&Arg, 1),
6784  Loc, ConstructorArgs))
6785  return ExprError();
6786 
6787  // Build an expression that constructs a temporary.
6788  CurInit = S.BuildCXXConstructExpr(Loc, Step->Type,
6789  FoundFn, Constructor,
6790  ConstructorArgs,
6791  HadMultipleCandidates,
6792  /*ListInit*/ false,
6793  /*StdInitListInit*/ false,
6794  /*ZeroInit*/ false,
6796  SourceRange());
6797  if (CurInit.isInvalid())
6798  return ExprError();
6799 
6800  S.CheckConstructorAccess(Kind.getLocation(), Constructor, FoundFn,
6801  Entity);
6802  if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
6803  return ExprError();
6804 
6805  CastKind = CK_ConstructorConversion;
6806  CreatedObject = true;
6807  } else {
6808  // Build a call to the conversion function.
6809  CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
6810  S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), nullptr,
6811  FoundFn);
6812  if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
6813  return ExprError();
6814 
6815  // FIXME: Should we move this initialization into a separate
6816  // derived-to-base conversion? I believe the answer is "no", because
6817  // we don't want to turn off access control here for c-style casts.
6818  CurInit = S.PerformObjectArgumentInitialization(CurInit.get(),
6819  /*Qualifier=*/nullptr,
6820  FoundFn, Conversion);
6821  if (CurInit.isInvalid())
6822  return ExprError();
6823 
6824  // Build the actual call to the conversion function.
6825  CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion,
6826  HadMultipleCandidates);
6827  if (CurInit.isInvalid())
6828  return ExprError();
6829 
6830  CastKind = CK_UserDefinedConversion;
6831  CreatedObject = Conversion->getReturnType()->isRecordType();
6832  }
6833 
6834  if (CreatedObject && checkAbstractType(CurInit.get()->getType()))
6835  return ExprError();
6836 
6837  CurInit = ImplicitCastExpr::Create(S.Context, CurInit.get()->getType(),
6838  CastKind, CurInit.get(), nullptr,
6839  CurInit.get()->getValueKind());
6840 
6841  if (shouldBindAsTemporary(Entity))
6842  // The overall entity is temporary, so this expression should be
6843  // destroyed at the end of its full-expression.
6844  CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
6845  else if (CreatedObject && shouldDestroyEntity(Entity)) {
6846  // The object outlasts the full-expression, but we need to prepare for
6847  // a destructor being run on it.
6848  // FIXME: It makes no sense to do this here. This should happen
6849  // regardless of how we initialized the entity.
6850  QualType T = CurInit.get()->getType();
6851  if (const RecordType *Record = T->getAs<RecordType>()) {
6852  CXXDestructorDecl *Destructor
6853  = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl()));
6854  S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor,
6855  S.PDiag(diag::err_access_dtor_temp) << T);
6856  S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor);
6857  if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart()))
6858  return ExprError();
6859  }
6860  }
6861  break;
6862  }
6863 
6867  // Perform a qualification conversion; these can never go wrong.
6868  ExprValueKind VK =
6870  VK_LValue :
6872  VK_XValue :
6873  VK_RValue);
6874  CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type, CK_NoOp, VK);
6875  break;
6876  }
6877 
6878  case SK_AtomicConversion: {
6879  assert(CurInit.get()->isRValue() && "cannot convert glvalue to atomic");
6880  CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6881  CK_NonAtomicToAtomic, VK_RValue);
6882  break;
6883  }
6884 
6885  case SK_LValueToRValue: {
6886  assert(CurInit.get()->isGLValue() && "cannot load from a prvalue");
6887  CurInit = ImplicitCastExpr::Create(S.Context, Step->Type,
6888  CK_LValueToRValue, CurInit.get(),
6889  /*BasePath=*/nullptr, VK_RValue);
6890  break;
6891  }
6892 
6893  case SK_ConversionSequence:
6900  ExprResult CurInitExprRes =
6901  S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,
6902  getAssignmentAction(Entity), CCK);
6903  if (CurInitExprRes.isInvalid())
6904  return ExprError();
6905 
6907 
6908  CurInit = CurInitExprRes;
6909 
6911  S.getLangOpts().CPlusPlus)
6912  DiagnoseNarrowingInInitList(S, *Step->ICS, SourceType, Entity.getType(),
6913  CurInit.get());
6914 
6915  break;
6916  }
6917 
6918  case SK_ListInitialization: {
6919  if (checkAbstractType(Step->Type))
6920  return ExprError();
6921 
6922  InitListExpr *InitList = cast<InitListExpr>(CurInit.get());
6923  // If we're not initializing the top-level entity, we need to create an
6924  // InitializeTemporary entity for our target type.
6925  QualType Ty = Step->Type;
6926  bool IsTemporary = !S.Context.hasSameType(Entity.getType(), Ty);
6928  InitializedEntity InitEntity = IsTemporary ? TempEntity : Entity;
6929  InitListChecker PerformInitList(S, InitEntity,
6930  InitList, Ty, /*VerifyOnly=*/false,
6931  /*TreatUnavailableAsInvalid=*/false);
6932  if (PerformInitList.HadError())
6933  return ExprError();
6934 
6935  // Hack: We must update *ResultType if available in order to set the
6936  // bounds of arrays, e.g. in 'int ar[] = {1, 2, 3};'.
6937  // Worst case: 'const int (&arref)[] = {1, 2, 3};'.
6938  if (ResultType &&
6939  ResultType->getNonReferenceType()->isIncompleteArrayType()) {
6940  if ((*ResultType)->isRValueReferenceType())
6941  Ty = S.Context.getRValueReferenceType(Ty);
6942  else if ((*ResultType)->isLValueReferenceType())
6943  Ty = S.Context.getLValueReferenceType(Ty,
6944  (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue());
6945  *ResultType = Ty;
6946  }
6947 
6948  InitListExpr *StructuredInitList =
6949  PerformInitList.getFullyStructuredList();
6950  CurInit.get();
6951  CurInit = shouldBindAsTemporary(InitEntity)
6952  ? S.MaybeBindToTemporary(StructuredInitList)
6953  : StructuredInitList;
6954  break;
6955  }
6956 
6958  if (checkAbstractType(Step->Type))
6959  return ExprError();
6960 
6961  // When an initializer list is passed for a parameter of type "reference
6962  // to object", we don't get an EK_Temporary entity, but instead an
6963  // EK_Parameter entity with reference type.
6964  // FIXME: This is a hack. What we really should do is create a user
6965  // conversion step for this case, but this makes it considerably more
6966  // complicated. For now, this will do.
6968  Entity.getType().getNonReferenceType());
6969  bool UseTemporary = Entity.getType()->isReferenceType();
6970  assert(Args.size() == 1 && "expected a single argument for list init");
6971  InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6972  S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
6973  << InitList->getSourceRange();
6974  MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
6975  CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
6976  Entity,
6977  Kind, Arg, *Step,
6978  ConstructorInitRequiresZeroInit,
6979  /*IsListInitialization*/true,
6980  /*IsStdInitListInit*/false,
6981  InitList->getLBraceLoc(),
6982  InitList->getRBraceLoc());
6983  break;
6984  }
6985 
6986  case SK_UnwrapInitList:
6987  CurInit = cast<InitListExpr>(CurInit.get())->getInit(0);
6988  break;
6989 
6990  case SK_RewrapInitList: {
6991  Expr *E = CurInit.get();
6992  InitListExpr *Syntactic = Step->WrappingSyntacticList;
6993  InitListExpr *ILE = new (S.Context) InitListExpr(S.Context,
6994  Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc());
6995  ILE->setSyntacticForm(Syntactic);
6996  ILE->setType(E->getType());
6997  ILE->setValueKind(E->getValueKind());
6998  CurInit = ILE;
6999  break;
7000  }
7001 
7004  if (checkAbstractType(Step->Type))
7005  return ExprError();
7006 
7007  // When an initializer list is passed for a parameter of type "reference
7008  // to object", we don't get an EK_Temporary entity, but instead an
7009  // EK_Parameter entity with reference type.
7010  // FIXME: This is a hack. What we really should do is create a user
7011  // conversion step for this case, but this makes it considerably more
7012  // complicated. For now, this will do.
7014  Entity.getType().getNonReferenceType());
7015  bool UseTemporary = Entity.getType()->isReferenceType();
7016  bool IsStdInitListInit =
7018  Expr *Source = CurInit.get();
7020  S, UseTemporary ? TempEntity : Entity, Kind,
7021  Source ? MultiExprArg(Source) : Args, *Step,
7022  ConstructorInitRequiresZeroInit,
7023  /*IsListInitialization*/ IsStdInitListInit,
7024  /*IsStdInitListInitialization*/ IsStdInitListInit,
7025  /*LBraceLoc*/ SourceLocation(),
7026  /*RBraceLoc*/ SourceLocation());
7027  break;
7028  }
7029 
7030  case SK_ZeroInitialization: {
7031  step_iterator NextStep = Step;
7032  ++NextStep;
7033  if (NextStep != StepEnd &&
7034  (NextStep->Kind == SK_ConstructorInitialization ||
7035  NextStep->Kind == SK_ConstructorInitializationFromList)) {
7036  // The need for zero-initialization is recorded directly into
7037  // the call to the object's constructor within the next step.
7038  ConstructorInitRequiresZeroInit = true;
7039  } else if (Kind.getKind() == InitializationKind::IK_Value &&
7040  S.getLangOpts().CPlusPlus &&
7041  !Kind.isImplicitValueInit()) {
7042  TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
7043  if (!TSInfo)
7045  Kind.getRange().getBegin());
7046 
7047  CurInit = new (S.Context) CXXScalarValueInitExpr(
7048  Entity.getType().getNonLValueExprType(S.Context), TSInfo,
7049  Kind.getRange().getEnd());
7050  } else {
7051  CurInit = new (S.Context) ImplicitValueInitExpr(Step->Type);
7052  }
7053  break;
7054  }
7055 
7056  case SK_CAssignment: {
7057  QualType SourceType = CurInit.get()->getType();
7058  // Save off the initial CurInit in case we need to emit a diagnostic
7059  ExprResult InitialCurInit = CurInit;
7060  ExprResult Result = CurInit;
7061  Sema::AssignConvertType ConvTy =
7062  S.CheckSingleAssignmentConstraints(Step->Type, Result, true,
7064  if (Result.isInvalid())
7065  return ExprError();
7066  CurInit = Result;
7067 
7068  // If this is a call, allow conversion to a transparent union.
7069  ExprResult CurInitExprRes = CurInit;
7070  if (ConvTy != Sema::Compatible &&
7071  Entity.isParameterKind() &&
7073  == Sema::Compatible)
7074  ConvTy = Sema::Compatible;
7075  if (CurInitExprRes.isInvalid())
7076  return ExprError();
7077  CurInit = CurInitExprRes;
7078 
7079  bool Complained;
7080  if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
7081  Step->Type, SourceType,
7082  InitialCurInit.get(),
7083  getAssignmentAction(Entity, true),
7084  &Complained)) {
7085  PrintInitLocationNote(S, Entity);
7086  return ExprError();
7087  } else if (Complained)
7088  PrintInitLocationNote(S, Entity);
7089  break;
7090  }
7091 
7092  case SK_StringInit: {
7093  QualType Ty = Step->Type;
7094  CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty,
7095  S.Context.getAsArrayType(Ty), S);
7096  break;
7097  }
7098 
7100  CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
7101  CK_ObjCObjectLValueCast,
7102  CurInit.get()->getValueKind());
7103  break;
7104 
7105  case SK_ArrayLoopIndex: {
7106  Expr *Cur = CurInit.get();
7107  Expr *BaseExpr = new (S.Context)
7108  OpaqueValueExpr(Cur->getExprLoc(), Cur->getType(),
7109  Cur->getValueKind(), Cur->getObjectKind(), Cur);
7110  Expr *IndexExpr =
7112  CurInit = S.CreateBuiltinArraySubscriptExpr(
7113  BaseExpr, Kind.getLocation(), IndexExpr, Kind.getLocation());
7114  ArrayLoopCommonExprs.push_back(BaseExpr);
7115  break;
7116  }
7117 
7118  case SK_ArrayLoopInit: {
7119  assert(!ArrayLoopCommonExprs.empty() &&
7120  "mismatched SK_ArrayLoopIndex and SK_ArrayLoopInit");
7121  Expr *Common = ArrayLoopCommonExprs.pop_back_val();
7122  CurInit = new (S.Context) ArrayInitLoopExpr(Step->Type, Common,
7123  CurInit.get());
7124  break;
7125  }
7126 
7127  case SK_GNUArrayInit:
7128  // Okay: we checked everything before creating this step. Note that
7129  // this is a GNU extension.
7130  S.Diag(Kind.getLocation(), diag::ext_array_init_copy)
7131  << Step->Type << CurInit.get()->getType()
7132  << CurInit.get()->getSourceRange();
7133  LLVM_FALLTHROUGH;
7134  case SK_ArrayInit:
7135  // If the destination type is an incomplete array type, update the
7136  // type accordingly.
7137  if (ResultType) {
7138  if (const IncompleteArrayType *IncompleteDest
7140  if (const ConstantArrayType *ConstantSource
7141  = S.Context.getAsConstantArrayType(CurInit.get()->getType())) {
7142  *ResultType = S.Context.getConstantArrayType(
7143  IncompleteDest->getElementType(),
7144  ConstantSource->getSize(),
7145  ArrayType::Normal, 0);
7146  }
7147  }
7148  }
7149  break;
7150 
7152  // Okay: we checked everything before creating this step. Note that
7153  // this is a GNU extension.
7154  S.Diag(Kind.getLocation(), diag::ext_array_init_parens)
7155  << CurInit.get()->getSourceRange();
7156  break;
7157 
7160  checkIndirectCopyRestoreSource(S, CurInit.get());
7161  CurInit = new (S.Context) ObjCIndirectCopyRestoreExpr(
7162  CurInit.get(), Step->Type,
7164  break;
7165 
7166  case SK_ProduceObjCObject:
7167  CurInit =
7168  ImplicitCastExpr::Create(S.Context, Step->Type, CK_ARCProduceObject,
7169  CurInit.get(), nullptr, VK_RValue);
7170  break;
7171 
7172  case SK_StdInitializerList: {
7173  S.Diag(CurInit.get()->getExprLoc(),
7174  diag::warn_cxx98_compat_initializer_list_init)
7175  << CurInit.get()->getSourceRange();
7176 
7177  // Materialize the temporary into memory.
7179  CurInit.get()->getType(), CurInit.get(),
7180  /*BoundToLvalueReference=*/false);
7181 
7182  // Maybe lifetime-extend the array temporary's subobjects to match the
7183  // entity's lifetime.
7184  if (const InitializedEntity *ExtendingEntity =
7186  if (performReferenceExtension(MTE, ExtendingEntity))
7187  warnOnLifetimeExtension(S, Entity, CurInit.get(),
7188  /*IsInitializerList=*/true,
7189  ExtendingEntity->getDecl());
7190 
7191  // Wrap it in a construction of a std::initializer_list<T>.
7192  CurInit = new (S.Context) CXXStdInitializerListExpr(Step->Type, MTE);
7193 
7194  // Bind the result, in case the library has given initializer_list a
7195  // non-trivial destructor.
7196  if (shouldBindAsTemporary(Entity))
7197  CurInit = S.MaybeBindToTemporary(CurInit.get());
7198  break;
7199  }
7200 
7201  case SK_OCLSamplerInit: {
7202  // Sampler initialzation have 5 cases:
7203  // 1. function argument passing
7204  // 1a. argument is a file-scope variable
7205  // 1b. argument is a function-scope variable
7206  // 1c. argument is one of caller function's parameters
7207  // 2. variable initialization
7208  // 2a. initializing a file-scope variable
7209  // 2b. initializing a function-scope variable
7210  //
7211  // For file-scope variables, since they cannot be initialized by function
7212  // call of __translate_sampler_initializer in LLVM IR, their references
7213  // need to be replaced by a cast from their literal initializers to
7214  // sampler type. Since sampler variables can only be used in function
7215  // calls as arguments, we only need to replace them when handling the
7216  // argument passing.
7217  assert(Step->Type->isSamplerT() &&
7218  "Sampler initialization on non-sampler type.");
7219  Expr *Init = CurInit.get();
7220  QualType SourceType = Init->getType();
7221  // Case 1
7222  if (Entity.isParameterKind()) {
7223  if (!SourceType->isSamplerT() && !SourceType->isIntegerType()) {
7224  S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
7225  << SourceType;
7226  break;
7227  } else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init)) {
7228  auto Var = cast<VarDecl>(DRE->getDecl());
7229  // Case 1b and 1c
7230  // No cast from integer to sampler is needed.
7231  if (!Var->hasGlobalStorage()) {
7232  CurInit = ImplicitCastExpr::Create(S.Context, Step->Type,
7233  CK_LValueToRValue, Init,
7234  /*BasePath=*/nullptr, VK_RValue);
7235  break;
7236  }
7237  // Case 1a
7238  // For function call with a file-scope sampler variable as argument,
7239  // get the integer literal.
7240  // Do not diagnose if the file-scope variable does not have initializer
7241  // since this has already been diagnosed when parsing the variable
7242  // declaration.
7243  if (!Var->getInit() || !isa<ImplicitCastExpr>(Var->getInit()))
7244  break;
7245  Init = cast<ImplicitCastExpr>(const_cast<Expr*>(
7246  Var->getInit()))->getSubExpr();
7247  SourceType = Init->getType();
7248  }
7249  } else {
7250  // Case 2
7251  // Check initializer is 32 bit integer constant.
7252  // If the initializer is taken from global variable, do not diagnose since
7253  // this has already been done when parsing the variable declaration.
7254  if (!Init->isConstantInitializer(S.Context, false))
7255  break;
7256 
7257  if (!SourceType->isIntegerType() ||
7258  32 != S.Context.getIntWidth(SourceType)) {
7259  S.Diag(Kind.getLocation(), diag::err_sampler_initializer_not_integer)
7260  << SourceType;
7261  break;
7262  }
7263 
7264  llvm::APSInt Result;
7265  Init->EvaluateAsInt(Result, S.Context);
7266  const uint64_t SamplerValue = Result.getLimitedValue();
7267  // 32-bit value of sampler's initializer is interpreted as
7268  // bit-field with the following structure:
7269  // |unspecified|Filter|Addressing Mode| Normalized Coords|
7270  // |31 6|5 4|3 1| 0|
7271  // This structure corresponds to enum values of sampler properties
7272  // defined in SPIR spec v1.2 and also opencl-c.h
7273  unsigned AddressingMode = (0x0E & SamplerValue) >> 1;
7274  unsigned FilterMode = (0x30 & SamplerValue) >> 4;
7275  if (FilterMode != 1 && FilterMode != 2)
7276  S.Diag(Kind.getLocation(),
7277  diag::warn_sampler_initializer_invalid_bits)
7278  << "Filter Mode";
7279  if (AddressingMode > 4)
7280  S.Diag(Kind.getLocation(),
7281  diag::warn_sampler_initializer_invalid_bits)
7282  << "Addressing Mode";
7283  }
7284 
7285  // Cases 1a, 2a and 2b
7286  // Insert cast from integer to sampler.
7287  CurInit = S.ImpCastExprToType(Init, S.Context.OCLSamplerTy,
7288  CK_IntToOCLSampler);
7289  break;
7290  }
7291  case SK_OCLZeroEvent: {
7292  assert(Step->Type->isEventT() &&
7293  "Event initialization on non-event type.");
7294 
7295  CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
7296  CK_ZeroToOCLEvent,
7297  CurInit.get()->getValueKind());
7298  break;
7299  }
7300  case SK_OCLZeroQueue: {
7301  assert(Step->Type->isQueueT() &&
7302  "Event initialization on non queue type.");
7303 
7304  CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
7305  CK_ZeroToOCLQueue,
7306  CurInit.get()->getValueKind());
7307  break;
7308  }
7309  }
7310  }
7311 
7312  // Diagnose non-fatal problems with the completed initialization.
7313  if (Entity.getKind() == InitializedEntity::EK_Member &&
7314  cast<FieldDecl>(Entity.getDecl())->isBitField())
7315  S.CheckBitFieldInitialization(Kind.getLocation(),
7316  cast<FieldDecl>(Entity.getDecl()),
7317  CurInit.get());
7318 
7319  // Check for std::move on construction.
7320  if (const Expr *E = CurInit.get()) {
7323  }
7324 
7325  return CurInit;
7326 }
7327 
7328 /// Somewhere within T there is an uninitialized reference subobject.
7329 /// Dig it out and diagnose it.
7331  QualType T) {
7332  if (T->isReferenceType()) {
7333  S.Diag(Loc, diag::err_reference_without_init)
7334  << T.getNonReferenceType();
7335  return true;
7336  }
7337 
7339  if (!RD || !RD->hasUninitializedReferenceMember())
7340  return false;
7341 
7342  for (const auto *FI : RD->fields()) {
7343  if (FI->isUnnamedBitfield())
7344  continue;
7345 
7346  if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {
7347  S.Diag(Loc, diag::note_value_initialization_here) << RD;
7348  return true;
7349  }
7350  }
7351 
7352  for (const auto &BI : RD->bases()) {
7353  if (DiagnoseUninitializedReference(S, BI.getLocStart(), BI.getType())) {
7354  S.Diag(Loc, diag::note_value_initialization_here) << RD;
7355  return true;
7356  }
7357  }
7358 
7359  return false;
7360 }
7361 
7362 
7363 //===----------------------------------------------------------------------===//
7364 // Diagnose initialization failures
7365 //===----------------------------------------------------------------------===//
7366 
7367 /// Emit notes associated with an initialization that failed due to a
7368 /// "simple" conversion failure.
7369 static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity,
7370  Expr *op) {
7371  QualType destType = entity.getType();
7372  if (destType.getNonReferenceType()->isObjCObjectPointerType() &&
7373  op->getType()->isObjCObjectPointerType()) {
7374 
7375  // Emit a possible note about the conversion failing because the
7376  // operand is a message send with a related result type.
7378 
7379  // Emit a possible note about a return failing because we're
7380  // expecting a related result type.
7381  if (entity.getKind() == InitializedEntity::EK_Result)
7383  }
7384 }
7385 
7386 static void diagnoseListInit(Sema &S, const InitializedEntity &Entity,
7387  InitListExpr *InitList) {
7388  QualType DestType = Entity.getType();
7389 
7390  QualType E;
7391  if (S.getLangOpts().CPlusPlus11 && S.isStdInitializerList(DestType, &E)) {
7393  E.withConst(),
7394  llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
7395  InitList->getNumInits()),
7397  InitializedEntity HiddenArray =
7399  return diagnoseListInit(S, HiddenArray, InitList);
7400  }
7401 
7402  if (DestType->isReferenceType()) {
7403  // A list-initialization failure for a reference means that we tried to
7404  // create a temporary of the inner type (per [dcl.init.list]p3.6) and the
7405  // inner initialization failed.
7406  QualType T = DestType->getAs<ReferenceType>()->getPointeeType();
7408  SourceLocation Loc = InitList->getLocStart();
7409  if (auto *D = Entity.getDecl())
7410  Loc = D->getLocation();
7411  S.Diag(Loc, diag::note_in_reference_temporary_list_initializer) << T;
7412  return;
7413  }
7414 
7415  InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
7416  /*VerifyOnly=*/false,
7417  /*TreatUnavailableAsInvalid=*/false);
7418  assert(DiagnoseInitList.HadError() &&
7419  "Inconsistent init list check result.");
7420 }
7421 
7423  const InitializedEntity &Entity,
7424  const InitializationKind &Kind,
7425  ArrayRef<Expr *> Args) {
7426  if (!Failed())
7427  return false;
7428 
7429  QualType DestType = Entity.getType();
7430  switch (Failure) {
7432  // FIXME: Customize for the initialized entity?
7433  if (Args.empty()) {
7434  // Dig out the reference subobject which is uninitialized and diagnose it.
7435  // If this is value-initialization, this could be nested some way within
7436  // the target type.
7437  assert(Kind.getKind() == InitializationKind::IK_Value ||
7438  DestType->isReferenceType());
7439  bool Diagnosed =
7440  DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
7441  assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
7442  (void)Diagnosed;
7443  } else // FIXME: diagnostic below could be better!
7444  S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
7445  << SourceRange(Args.front()->getLocStart(), Args.back()->getLocEnd());
7446  break;
7448  S.Diag(Kind.getLocation(), diag::err_list_init_in_parens)
7449  << 1 << Entity.getType() << Args[0]->getSourceRange();
7450  break;
7451 
7452  case FK_ArrayNeedsInitList:
7453  S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
7454  break;
7456  S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
7457  break;
7459  S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
7460  break;
7462  S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
7463  break;
7465  S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
7466  break;
7468  S.Diag(Kind.getLocation(),
7469  diag::err_array_init_incompat_wide_string_into_wchar);
7470  break;
7471  case FK_ArrayTypeMismatch:
7473  S.Diag(Kind.getLocation(),
7474  (Failure == FK_ArrayTypeMismatch
7475  ? diag::err_array_init_different_type
7476  : diag::err_array_init_non_constant_array))
7477  << DestType.getNonReferenceType()
7478  << Args[0]->getType()
7479  << Args[0]->getSourceRange();
7480  break;
7481 
7483  S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
7484  << Args[0]->getSourceRange();
7485  break;
7486 
7488  DeclAccessPair Found;
7490  DestType.getNonReferenceType(),
7491  true,
7492  Found);
7493  break;
7494  }
7495 
7497  auto *FD = cast<FunctionDecl>(cast<DeclRefExpr>(Args[0])->getDecl());
7498  S.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
7499  Args[0]->getLocStart());
7500  break;
7501  }
7502 
7505  switch (FailedOverloadResult) {
7506  case OR_Ambiguous:
7507  if (Failure == FK_UserConversionOverloadFailed)
7508  S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
7509  << Args[0]->getType() << DestType
7510  << Args[0]->getSourceRange();
7511  else
7512  S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
7513  << DestType << Args[0]->getType()
7514  << Args[0]->getSourceRange();
7515 
7516  FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
7517  break;
7518 
7519  case OR_No_Viable_Function:
7520  if (!S.RequireCompleteType(Kind.getLocation(),
7521  DestType.getNonReferenceType(),
7522  diag::err_typecheck_nonviable_condition_incomplete,
7523  Args[0]->getType(), Args[0]->getSourceRange()))
7524  S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
7525  << (Entity.getKind() == InitializedEntity::EK_Result)
7526  << Args[0]->getType() << Args[0]->getSourceRange()
7527  << DestType.getNonReferenceType();
7528 
7529  FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
7530  break;
7531 
7532  case OR_Deleted: {
7533  S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
7534  << Args[0]->getType() << DestType.getNonReferenceType()
7535  << Args[0]->getSourceRange();
7537  OverloadingResult Ovl
7538  = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best,
7539  true);
7540  if (Ovl == OR_Deleted) {
7541  S.NoteDeletedFunction(Best->Function);
7542  } else {
7543  llvm_unreachable("Inconsistent overload resolution?");
7544  }
7545  break;
7546  }
7547 
7548  case OR_Success:
7549  llvm_unreachable("Conversion did not fail!");
7550  }
7551  break;
7552 
7554  if (isa<InitListExpr>(Args[0])) {
7555  S.Diag(Kind.getLocation(),
7556  diag::err_lvalue_reference_bind_to_initlist)
7558  << DestType.getNonReferenceType()
7559  << Args[0]->getSourceRange();
7560  break;
7561  }
7562  // Intentional fallthrough
7563 
7565  S.Diag(Kind.getLocation(),
7567  ? diag::err_lvalue_reference_bind_to_temporary
7568  : diag::err_lvalue_reference_bind_to_unrelated)
7570  << DestType.getNonReferenceType()
7571  << Args[0]->getType()
7572  << Args[0]->getSourceRange();
7573  break;
7574 
7576  // We don't necessarily have an unambiguous source bit-field.
7577  FieldDecl *BitField = Args[0]->getSourceBitField();
7578  S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
7579  << DestType.isVolatileQualified()
7580  << (BitField ? BitField->getDeclName() : DeclarationName())
7581  << (BitField != nullptr)
7582  << Args[0]->getSourceRange();
7583  if (BitField)
7584  S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
7585  break;
7586  }
7587 
7589  S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
7590  << DestType.isVolatileQualified()
7591  << Args[0]->getSourceRange();
7592  break;
7593 
7595  S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
7596  << DestType.getNonReferenceType() << Args[0]->getType()
7597  << Args[0]->getSourceRange();
7598  break;
7599 
7601  QualType SourceType = Args[0]->getType();
7602  QualType NonRefType = DestType.getNonReferenceType();
7603  Qualifiers DroppedQualifiers =
7604  SourceType.getQualifiers() - NonRefType.getQualifiers();
7605 
7606  S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
7607  << SourceType
7608  << NonRefType
7609  << DroppedQualifiers.getCVRQualifiers()
7610  << Args[0]->getSourceRange();
7611  break;
7612  }
7613 
7615  S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
7616  << DestType.getNonReferenceType()
7617  << Args[0]->isLValue()
7618  << Args[0]->getType()
7619  << Args[0]->getSourceRange();
7620  emitBadConversionNotes(S, Entity, Args[0]);
7621  break;
7622 
7623  case FK_ConversionFailed: {
7624  QualType FromType = Args[0]->getType();
7625  PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
7626  << (int)Entity.getKind()
7627  << DestType
7628  << Args[0]->isLValue()
7629  << FromType
7630  << Args[0]->getSourceRange();
7631  S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
7632  S.Diag(Kind.getLocation(), PDiag);
7633  emitBadConversionNotes(S, Entity, Args[0]);
7634  break;
7635  }
7636 
7638  // No-op. This error has already been reported.
7639  break;
7640 
7641  case FK_TooManyInitsForScalar: {
7642  SourceRange R;
7643 
7644  auto *InitList = dyn_cast<InitListExpr>(Args[0]);
7645  if (InitList && InitList->getNumInits() >= 1) {
7646  R = SourceRange(InitList->getInit(0)->getLocEnd(), InitList->getLocEnd());
7647  } else {
7648  assert(Args.size() > 1 && "Expected multiple initializers!");
7649  R = SourceRange(Args.front()->getLocEnd(), Args.back()->getLocEnd());
7650  }
7651 
7653  if (Kind.isCStyleOrFunctionalCast())
7654  S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
7655  << R;
7656  else
7657  S.Diag(Kind.getLocation(), diag::err_excess_initializers)
7658  << /*scalar=*/2 << R;
7659  break;
7660  }
7661 
7663  S.Diag(Kind.getLocation(), diag::err_list_init_in_parens)
7664  << 0 << Entity.getType() << Args[0]->getSourceRange();
7665  break;
7666 
7668  S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
7669  << DestType.getNonReferenceType() << Args[0]->getSourceRange();
7670  break;
7671 
7673  S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
7674  << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
7675  break;
7676 
7679  SourceRange ArgsRange;
7680  if (Args.size())
7681  ArgsRange = SourceRange(Args.front()->getLocStart(),
7682  Args.back()->getLocEnd());
7683 
7684  if (Failure == FK_ListConstructorOverloadFailed) {
7685  assert(Args.size() == 1 &&
7686  "List construction from other than 1 argument.");
7687  InitListExpr *InitList = cast<InitListExpr>(Args[0]);
7688  Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
7689  }
7690 
7691  // FIXME: Using "DestType" for the entity we're printing is probably
7692  // bad.
7693  switch (FailedOverloadResult) {
7694  case OR_Ambiguous:
7695  S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
7696  << DestType << ArgsRange;
7697  FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
7698  break;
7699 
7700  case OR_No_Viable_Function:
7701  if (Kind.getKind() == InitializationKind::IK_Default &&
7702  (Entity.getKind() == InitializedEntity::EK_Base ||
7703  Entity.getKind() == InitializedEntity::EK_Member) &&
7704  isa<CXXConstructorDecl>(S.CurContext)) {
7705  // This is implicit default initialization of a member or
7706  // base within a constructor. If no viable function was
7707  // found, notify the user that they need to explicitly
7708  // initialize this base/member.
7709  CXXConstructorDecl *Constructor
7710  = cast<CXXConstructorDecl>(S.CurContext);
7711  const CXXRecordDecl *InheritedFrom = nullptr;
7712  if (auto Inherited = Constructor->getInheritedConstructor())
7713  InheritedFrom = Inherited.getShadowDecl()->getNominatedBaseClass();
7714  if (Entity.getKind() == InitializedEntity::EK_Base) {
7715  S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
7716  << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
7717  << S.Context.getTypeDeclType(Constructor->getParent())
7718  << /*base=*/0
7719  << Entity.getType()
7720  << InheritedFrom;
7721 
7722  RecordDecl *BaseDecl
7723  = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
7724  ->getDecl();
7725  S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
7726  << S.Context.getTagDeclType(BaseDecl);
7727  } else {
7728  S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
7729  << (InheritedFrom ? 2 : Constructor->isImplicit() ? 1 : 0)
7730  << S.Context.getTypeDeclType(Constructor->getParent())
7731  << /*member=*/1
7732  << Entity.getName()
7733  << InheritedFrom;
7734  S.Diag(Entity.getDecl()->getLocation(),
7735  diag::note_member_declared_at);
7736 
7737  if (const RecordType *Record
7738  = Entity.getType()->getAs<RecordType>())
7739  S.Diag(Record->getDecl()->getLocation(),
7740  diag::note_previous_decl)
7741  << S.Context.getTagDeclType(Record->getDecl());
7742  }
7743  break;
7744  }
7745 
7746  S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
7747  << DestType << ArgsRange;
7748  FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
7749  break;
7750 
7751  case OR_Deleted: {
7753  OverloadingResult Ovl
7754  = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
7755  if (Ovl != OR_Deleted) {
7756  S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
7757  << true << DestType << ArgsRange;
7758  llvm_unreachable("Inconsistent overload resolution?");
7759  break;
7760  }
7761 
7762  // If this is a defaulted or implicitly-declared function, then
7763  // it was implicitly deleted. Make it clear that the deletion was
7764  // implicit.
7765  if (S.isImplicitlyDeleted(Best->Function))
7766  S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
7767  << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
7768  << DestType << ArgsRange;
7769  else
7770  S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
7771  << true << DestType << ArgsRange;
7772 
7773  S.NoteDeletedFunction(Best->Function);
7774  break;
7775  }
7776 
7777  case OR_Success:
7778  llvm_unreachable("Conversion did not fail!");
7779  }
7780  }
7781  break;
7782 
7783  case FK_DefaultInitOfConst:
7784  if (Entity.getKind() == InitializedEntity::EK_Member &&
7785  isa<CXXConstructorDecl>(S.CurContext)) {
7786  // This is implicit default-initialization of a const member in
7787  // a constructor. Complain that it needs to be explicitly
7788  // initialized.
7789  CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
7790  S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
7791  << (Constructor->getInheritedConstructor() ? 2 :
7792  Constructor->isImplicit() ? 1 : 0)
7793  << S.Context.getTypeDeclType(Constructor->getParent())
7794  << /*const=*/1
7795  << Entity.getName();
7796  S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
7797  << Entity.getName();
7798  } else {
7799  S.Diag(Kind.getLocation(), diag::err_default_init_const)
7800  << DestType << (bool)DestType->getAs<RecordType>();
7801  }
7802  break;
7803 
7804  case FK_Incomplete:
7805  S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
7806  diag::err_init_incomplete_type);
7807  break;
7808 
7810  // Run the init list checker again to emit diagnostics.
7811  InitListExpr *InitList = cast<InitListExpr>(Args[0]);
7812  diagnoseListInit(S, Entity, InitList);
7813  break;
7814  }
7815 
7816  case FK_PlaceholderType: {
7817  // FIXME: Already diagnosed!
7818  break;
7819  }
7820 
7821  case FK_ExplicitConstructor: {
7822  S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
7823  << Args[0]->getSourceRange();
7825  OverloadingResult Ovl
7826  = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
7827  (void)Ovl;
7828  assert(Ovl == OR_Success && "Inconsistent overload resolution");
7829  CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
7830  S.Diag(CtorDecl->getLocation(),
7831  diag::note_explicit_ctor_deduction_guide_here) << false;
7832  break;
7833  }
7834  }
7835 
7836  PrintInitLocationNote(S, Entity);
7837  return true;
7838 }
7839 
7840 void InitializationSequence::dump(raw_ostream &OS) const {
7841  switch (SequenceKind) {
7842  case FailedSequence: {
7843  OS << "Failed sequence: ";
7844  switch (Failure) {
7846  OS << "too many initializers for reference";
7847  break;
7848 
7850  OS << "parenthesized list init for reference";
7851  break;
7852 
7853  case FK_ArrayNeedsInitList:
7854  OS << "array requires initializer list";
7855  break;
7856 
7858  OS << "address of unaddressable function was taken";
7859  break;
7860 
7862  OS << "array requires initializer list or string literal";
7863  break;
7864 
7866  OS << "array requires initializer list or wide string literal";
7867  break;
7868 
7870  OS << "narrow string into wide char array";
7871  break;
7872 
7874  OS << "wide string into char array";
7875  break;
7876 
7878  OS << "incompatible wide string into wide char array";
7879  break;
7880 
7881  case FK_ArrayTypeMismatch:
7882  OS << "array type mismatch";
7883  break;
7884 
7886  OS << "non-constant array initializer";
7887  break;
7888 
7890  OS << "address of overloaded function failed";
7891  break;
7892 
7894  OS << "overload resolution for reference initialization failed";
7895  break;
7896 
7898  OS << "non-const lvalue reference bound to temporary";
7899  break;
7900 
7902  OS << "non-const lvalue reference bound to bit-field";
7903  break;
7904 
7906  OS << "non-const lvalue reference bound to vector element";
7907  break;
7908 
7910  OS << "non-const lvalue reference bound to unrelated type";
7911  break;
7912 
7914  OS << "rvalue reference bound to an lvalue";
7915  break;
7916 
7918  OS << "reference initialization drops qualifiers";
7919  break;
7920 
7922  OS << "reference initialization failed";
7923  break;
7924 
7925  case FK_ConversionFailed:
7926  OS << "conversion failed";
7927  break;
7928 
7930  OS << "conversion from property failed";
7931  break;
7932 
7934  OS << "too many initializers for scalar";
7935  break;
7936 
7938  OS << "parenthesized list init for reference";
7939  break;
7940 
7942  OS << "referencing binding to initializer list";
7943  break;
7944 
7946  OS << "initializer list for non-aggregate, non-scalar type";
7947  break;
7948 
7950  OS << "overloading failed for user-defined conversion";
7951  break;
7952 
7954  OS << "constructor overloading failed";
7955  break;
7956 
7957  case FK_DefaultInitOfConst:
7958  OS << "default initialization of a const variable";
7959  break;
7960 
7961  case FK_Incomplete:
7962  OS << "initialization of incomplete type";
7963  break;
7964 
7966  OS << "list initialization checker failure";
7967  break;
7968 
7970  OS << "variable length array has an initializer";
7971  break;
7972 
7973  case FK_PlaceholderType:
7974  OS << "initializer expression isn't contextually valid";
7975  break;
7976 
7978  OS << "list constructor overloading failed";
7979  break;
7980 
7982  OS << "list copy initialization chose explicit constructor";
7983  break;
7984  }
7985  OS << '\n';
7986  return;
7987  }
7988 
7989  case DependentSequence:
7990  OS << "Dependent sequence\n";
7991  return;
7992 
7993  case NormalSequence:
7994  OS << "Normal sequence: ";
7995  break;
7996  }
7997 
7998  for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
7999  if (S != step_begin()) {
8000  OS << " -> ";
8001  }
8002 
8003  switch (S->Kind) {
8005  OS << "resolve address of overloaded function";
8006  break;
8007 
8009  OS << "derived-to-base (rvalue)";
8010  break;
8011 
8013  OS << "derived-to-base (xvalue)";
8014  break;
8015 
8017  OS << "derived-to-base (lvalue)";
8018  break;
8019 
8020  case SK_BindReference:
8021  OS << "bind reference to lvalue";
8022  break;
8023 
8025  OS << "bind reference to a temporary";
8026  break;
8027 
8028  case SK_FinalCopy:
8029  OS << "final copy in class direct-initialization";
8030  break;
8031 
8033  OS << "extraneous C++03 copy to temporary";
8034  break;
8035 
8036  case SK_UserConversion:
8037  OS << "user-defined conversion via " << *S->Function.Function;
8038  break;
8039 
8041  OS << "qualification conversion (rvalue)";
8042  break;
8043 
8045  OS << "qualification conversion (xvalue)";
8046  break;
8047 
8049  OS << "qualification conversion (lvalue)";
8050  break;
8051 
8052  case SK_AtomicConversion:
8053  OS << "non-atomic-to-atomic conversion";
8054  break;
8055 
8056  case SK_LValueToRValue:
8057  OS << "load (lvalue to rvalue)";
8058  break;
8059 
8060  case SK_ConversionSequence:
8061  OS << "implicit conversion sequence (";
8062  S->ICS->dump(); // FIXME: use OS
8063  OS << ")";
8064  break;
8065 
8067  OS << "implicit conversion sequence with narrowing prohibited (";
8068  S->ICS->dump(); // FIXME: use OS
8069  OS << ")";
8070  break;
8071 
8072  case SK_ListInitialization:
8073  OS << "list aggregate initialization";
8074  break;
8075 
8076  case SK_UnwrapInitList:
8077  OS << "unwrap reference initializer list";
8078  break;
8079 
8080  case SK_RewrapInitList:
8081  OS << "rewrap reference initializer list";
8082  break;
8083 
8085  OS << "constructor initialization";
8086  break;
8087 
8089  OS << "list initialization via constructor";
8090  break;
8091 
8092  case SK_ZeroInitialization:
8093  OS << "zero initialization";
8094  break;
8095 
8096  case SK_CAssignment:
8097  OS << "C assignment";
8098  break;
8099 
8100  case SK_StringInit:
8101  OS << "string initialization";
8102  break;
8103 
8105  OS << "Objective-C object conversion";
8106  break;
8107 
8108  case SK_ArrayLoopIndex:
8109  OS << "indexing for array initialization loop";
8110  break;
8111 
8112  case SK_ArrayLoopInit:
8113  OS << "array initialization loop";
8114  break;
8115 
8116  case SK_ArrayInit:
8117  OS << "array initialization";
8118  break;
8119 
8120  case SK_GNUArrayInit:
8121  OS << "array initialization (GNU extension)";
8122  break;
8123 
8125  OS << "parenthesized array initialization";
8126  break;
8127 
8129  OS << "pass by indirect copy and restore";
8130  break;
8131 
8133  OS << "pass by indirect restore";
8134  break;
8135 
8136  case SK_ProduceObjCObject:
8137  OS << "Objective-C object retension";
8138  break;
8139 
8140  case SK_StdInitializerList:
8141  OS << "std::initializer_list from initializer list";
8142  break;
8143 
8145  OS << "list initialization from std::initializer_list";
8146  break;
8147 
8148  case SK_OCLSamplerInit:
8149  OS << "OpenCL sampler_t from integer constant";
8150  break;
8151 
8152  case SK_OCLZeroEvent:
8153  OS << "OpenCL event_t from zero";
8154  break;
8155 
8156  case SK_OCLZeroQueue:
8157  OS << "OpenCL queue_t from zero";
8158  break;
8159  }
8160 
8161  OS << " [" << S->Type.getAsString() << ']';
8162  }
8163 
8164  OS << '\n';
8165 }
8166 
8168  dump(llvm::errs());
8169 }
8170 
8172  const ImplicitConversionSequence &ICS,
8173  QualType PreNarrowingType,
8174  QualType EntityType,
8175  const Expr *PostInit) {
8176  const StandardConversionSequence *SCS = nullptr;
8177  switch (ICS.getKind()) {
8179  SCS = &ICS.Standard;
8180  break;
8182  SCS = &ICS.UserDefined.After;
8183  break;
8187  return;
8188  }
8189 
8190  // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
8191  APValue ConstantValue;
8192  QualType ConstantType;
8193  switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
8194  ConstantType)) {
8195  case NK_Not_Narrowing:
8197  // No narrowing occurred.
8198  return;
8199 
8200  case NK_Type_Narrowing:
8201  // This was a floating-to-integer conversion, which is always considered a
8202  // narrowing conversion even if the value is a constant and can be
8203  // represented exactly as an integer.
8204  S.Diag(PostInit->getLocStart(),
8205  (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
8206  ? diag::warn_init_list_type_narrowing
8207  : diag::ext_init_list_type_narrowing)
8208  << PostInit->getSourceRange()
8209  << PreNarrowingType.getLocalUnqualifiedType()
8210  << EntityType.getLocalUnqualifiedType();
8211  break;
8212 
8213  case NK_Constant_Narrowing:
8214  // A constant value was narrowed.
8215  S.Diag(PostInit->getLocStart(),
8216  (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
8217  ? diag::warn_init_list_constant_narrowing
8218  : diag::ext_init_list_constant_narrowing)
8219  << PostInit->getSourceRange()
8220  << ConstantValue.getAsString(S.getASTContext(), ConstantType)
8221  << EntityType.getLocalUnqualifiedType();
8222  break;
8223 
8224  case NK_Variable_Narrowing:
8225  // A variable's value may have been narrowed.
8226  S.Diag(PostInit->getLocStart(),
8227  (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
8228  ? diag::warn_init_list_variable_narrowing
8229  : diag::ext_init_list_variable_narrowing)
8230  << PostInit->getSourceRange()
8231  << PreNarrowingType.getLocalUnqualifiedType()
8232  << EntityType.getLocalUnqualifiedType();
8233  break;
8234  }
8235 
8236  SmallString<128> StaticCast;
8237  llvm::raw_svector_ostream OS(StaticCast);
8238  OS << "static_cast<";
8239  if (const TypedefType *TT = EntityType->getAs<TypedefType>()) {
8240  // It's important to use the typedef's name if there is one so that the
8241  // fixit doesn't break code using types like int64_t.
8242  //
8243  // FIXME: This will break if the typedef requires qualification. But
8244  // getQualifiedNameAsString() includes non-machine-parsable components.
8245  OS << *TT->getDecl();
8246  } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>())
8247  OS << BT->getName(S.getLangOpts());
8248  else {
8249  // Oops, we didn't find the actual type of the variable. Don't emit a fixit
8250  // with a broken cast.
8251  return;
8252  }
8253  OS << ">(";
8254  S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_silence)
8255  << PostInit->getSourceRange()
8256  << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str())
8258  S.getLocForEndOfToken(PostInit->getLocEnd()), ")");
8259 }
8260 
8261 //===----------------------------------------------------------------------===//
8262 // Initialization helper functions
8263 //===----------------------------------------------------------------------===//
8264 bool
8266  ExprResult Init) {
8267  if (Init.isInvalid())
8268  return false;
8269 
8270  Expr *InitE = Init.get();
8271  assert(InitE && "No initialization expression");
8272 
8273  InitializationKind Kind
8275  InitializationSequence Seq(*this, Entity, Kind, InitE);
8276  return !Seq.Failed();
8277 }
8278 
8279 ExprResult
8281  SourceLocation EqualLoc,
8282  ExprResult Init,
8283  bool TopLevelOfInitList,
8284  bool AllowExplicit) {
8285  if (Init.isInvalid())
8286  return ExprError();
8287 
8288  Expr *InitE = Init.get();
8289  assert(InitE && "No initialization expression?");
8290 
8291  if (EqualLoc.isInvalid())
8292  EqualLoc = InitE->getLocStart();
8293 
8295  EqualLoc,
8296  AllowExplicit);
8297  InitializationSequence Seq(*this, Entity, Kind, InitE, TopLevelOfInitList);
8298 
8299  // Prevent infinite recursion when performing parameter copy-initialization.
8300  const bool ShouldTrackCopy =
8301  Entity.isParameterKind() && Seq.isConstructorInitialization();
8302  if (ShouldTrackCopy) {
8303  if (llvm::find(CurrentParameterCopyTypes, Entity.getType()) !=
8304  CurrentParameterCopyTypes.end()) {
8305  Seq.SetOverloadFailure(
8308 
8309  // Try to give a meaningful diagnostic note for the problematic
8310  // constructor.
8311  const auto LastStep = Seq.step_end() - 1;
8312  assert(LastStep->Kind ==
8314  const FunctionDecl *Function = LastStep->Function.Function;
8315  auto Candidate =
8316  llvm::find_if(Seq.getFailedCandidateSet(),
8317  [Function](const OverloadCandidate &Candidate) -> bool {
8318  return Candidate.Viable &&
8319  Candidate.Function == Function &&
8320  Candidate.Conversions.size() > 0;
8321  });
8322  if (Candidate != Seq.getFailedCandidateSet().end() &&
8323  Function->getNumParams() > 0) {
8324  Candidate->Viable = false;
8325  Candidate->FailureKind = ovl_fail_bad_conversion;
8326  Candidate->Conversions[0].setBad(BadConversionSequence::no_conversion,
8327  InitE,
8328  Function->getParamDecl(0)->getType());
8329  }
8330  }
8331  CurrentParameterCopyTypes.push_back(Entity.getType());
8332  }
8333 
8334  ExprResult Result = Seq.Perform(*this, Entity, Kind, InitE);
8335 
8336  if (ShouldTrackCopy)
8337  CurrentParameterCopyTypes.pop_back();
8338 
8339  return Result;
8340 }
8341 
8343  TypeSourceInfo *TSInfo, const InitializedEntity &Entity,
8344  const InitializationKind &Kind, MultiExprArg Inits) {
8345  auto *DeducedTST = dyn_cast<DeducedTemplateSpecializationType>(
8346  TSInfo->getType()->getContainedDeducedType());
8347  assert(DeducedTST && "not a deduced template specialization type");
8348 
8349  // We can only perform deduction for class templates.
8350  auto TemplateName = DeducedTST->getTemplateName();
8351  auto *Template =
8352  dyn_cast_or_null<ClassTemplateDecl>(TemplateName.getAsTemplateDecl());
8353  if (!Template) {
8354  Diag(Kind.getLocation(),
8355  diag::err_deduced_non_class_template_specialization_type)
8357  if (auto *TD = TemplateName.getAsTemplateDecl())
8358  Diag(TD->getLocation(), diag::note_template_decl_here);
8359  return QualType();
8360  }
8361 
8362  // Can't deduce from dependent arguments.
8364  return Context.DependentTy;
8365 
8366  // FIXME: Perform "exact type" matching first, per CWG discussion?
8367  // Or implement this via an implied 'T(T) -> T' deduction guide?
8368 
8369  // FIXME: Do we need/want a std::initializer_list<T> special case?
8370 
8371  // Look up deduction guides, including those synthesized from constructors.
8372  //
8373  // C++1z [over.match.class.deduct]p1:
8374  // A set of functions and function templates is formed comprising:
8375  // - For each constructor of the class template designated by the
8376  // template-name, a function template [...]
8377  // - For each deduction-guide, a function or function template [...]
8378  DeclarationNameInfo NameInfo(
8379  Context.DeclarationNames.getCXXDeductionGuideName(Template),
8380  TSInfo->getTypeLoc().getEndLoc());
8381  LookupResult Guides(*this, NameInfo, LookupOrdinaryName);
8382  LookupQualifiedName(Guides, Template->getDeclContext());
8383 
8384  // FIXME: Do not diagnose inaccessible deduction guides. The standard isn't
8385  // clear on this, but they're not found by name so access does not apply.
8386  Guides.suppressDiagnostics();
8387 
8388  // Figure out if this is list-initialization.
8390  (Inits.size() == 1 && Kind.getKind() != InitializationKind::IK_Direct)
8391  ? dyn_cast<InitListExpr>(Inits[0])
8392  : nullptr;
8393 
8394  // C++1z [over.match.class.deduct]p1:
8395  // Initialization and overload resolution are performed as described in
8396  // [dcl.init] and [over.match.ctor], [over.match.copy], or [over.match.list]
8397  // (as appropriate for the type of initialization performed) for an object
8398  // of a hypothetical class type, where the selected functions and function
8399  // templates are considered to be the constructors of that class type
8400  //
8401  // Since we know we're initializing a class type of a type unrelated to that
8402  // of the initializer, this reduces to something fairly reasonable.
8403  OverloadCandidateSet Candidates(Kind.getLocation(),
8406  auto tryToResolveOverload =
8407  [&](bool OnlyListConstructors) -> OverloadingResult {
8408  Candidates.clear();
8409  for (auto I = Guides.begin(), E = Guides.end(); I != E; ++I) {
8410  NamedDecl *D = (*I)->getUnderlyingDecl();
8411  if (D->isInvalidDecl())
8412  continue;
8413 
8414  auto *TD = dyn_cast<FunctionTemplateDecl>(D);
8415  auto *GD = dyn_cast_or_null<CXXDeductionGuideDecl>(
8416  TD ? TD->getTemplatedDecl() : dyn_cast<FunctionDecl>(D));
8417  if (!GD)
8418  continue;
8419 
8420  // C++ [over.match.ctor]p1: (non-list copy-initialization from non-class)
8421  // For copy-initialization, the candidate functions are all the
8422  // converting constructors (12.3.1) of that class.
8423  // C++ [over.match.copy]p1: (non-list copy-initialization from class)
8424  // The converting constructors of T are candidate functions.
8425  if (Kind.isCopyInit() && !ListInit) {
8426  // Only consider converting constructors.
8427  if (GD->isExplicit())
8428  continue;
8429 
8430  // When looking for a converting constructor, deduction guides that
8431  // could never be called with one argument are not interesting to
8432  // check or note.
8433  if (GD->getMinRequiredArguments() > 1 ||
8434  (GD->getNumParams() == 0 && !GD->isVariadic()))
8435  continue;
8436  }
8437 
8438  // C++ [over.match.list]p1.1: (first phase list initialization)
8439  // Initially, the candidate functions are the initializer-list
8440  // constructors of the class T
8441  if (OnlyListConstructors && !isInitListConstructor(GD))
8442  continue;
8443 
8444  // C++ [over.match.list]p1.2: (second phase list initialization)
8445  // the candidate functions are all the constructors of the class T
8446  // C++ [over.match.ctor]p1: (all other cases)
8447  // the candidate functions are all the constructors of the class of
8448  // the object being initialized
8449 
8450  // C++ [over.best.ics]p4:
8451  // When [...] the constructor [...] is a candidate by
8452  // - [over.match.copy] (in all cases)
8453  // FIXME: The "second phase of [over.match.list] case can also
8454  // theoretically happen here, but it's not clear whether we can
8455  // ever have a parameter of the right type.
8456  bool SuppressUserConversions = Kind.isCopyInit();
8457 
8458  if (TD)
8459  AddTemplateOverloadCandidate(TD, I.getPair(), /*ExplicitArgs*/ nullptr,
8460  Inits, Candidates,
8461  SuppressUserConversions);
8462  else
8463  AddOverloadCandidate(GD, I.getPair(), Inits, Candidates,
8464  SuppressUserConversions);
8465  }
8466  return Candidates.BestViableFunction(*this, Kind.getLocation(), Best);
8467  };
8468 
8470 
8471  // C++11 [over.match.list]p1, per DR1467: for list-initialization, first
8472  // try initializer-list constructors.
8473  if (ListInit) {
8474  bool TryListConstructors = true;
8475 
8476  // Try list constructors unless the list is empty and the class has one or
8477  // more default constructors, in which case those constructors win.
8478  if (!ListInit->getNumInits()) {
8479  for (NamedDecl *D : Guides) {
8480  auto *FD = dyn_cast<FunctionDecl>(D->getUnderlyingDecl());
8481  if (FD && FD->getMinRequiredArguments() == 0) {
8482  TryListConstructors = false;
8483  break;
8484  }
8485  }
8486  }
8487 
8488  if (TryListConstructors)
8489  Result = tryToResolveOverload(/*OnlyListConstructor*/true);
8490  // Then unwrap the initializer list and try again considering all
8491  // constructors.
8492  Inits = MultiExprArg(ListInit->getInits(), ListInit->getNumInits());
8493  }
8494 
8495  // If list-initialization fails, or if we're doing any other kind of
8496  // initialization, we (eventually) consider constructors.
8497  if (Result == OR_No_Viable_Function)
8498  Result = tryToResolveOverload(/*OnlyListConstructor*/false);
8499 
8500  switch (Result) {
8501  case OR_Ambiguous:
8502  Diag(Kind.getLocation(), diag::err_deduced_class_template_ctor_ambiguous)
8503  << TemplateName;
8504  // FIXME: For list-initialization candidates, it'd usually be better to
8505  // list why they were not viable when given the initializer list itself as
8506  // an argument.
8507  Candidates.NoteCandidates(*this, OCD_ViableCandidates, Inits);
8508  return QualType();
8509 
8510  case OR_No_Viable_Function: {
8511  CXXRecordDecl *Primary =
8512  cast<ClassTemplateDecl>(Template)->getTemplatedDecl();
8513  bool Complete =
8514  isCompleteType(Kind.getLocation(), Context.getTypeDeclType(Primary));
8515  Diag(Kind.getLocation(),
8516  Complete ? diag::err_deduced_class_template_ctor_no_viable
8517  : diag::err_deduced_class_template_incomplete)
8518  << TemplateName << !Guides.empty();
8519  Candidates.NoteCandidates(*this, OCD_AllCandidates, Inits);
8520  return QualType();
8521  }
8522 
8523  case OR_Deleted: {
8524  Diag(Kind.getLocation(), diag::err_deduced_class_template_deleted)
8525  << TemplateName;
8526  NoteDeletedFunction(Best->Function);
8527  return QualType();
8528  }
8529 
8530  case OR_Success:
8531  // C++ [over.match.list]p1:
8532  // In copy-list-initialization, if an explicit constructor is chosen, the
8533  // initialization is ill-formed.
8534  if (Kind.isCopyInit() && ListInit &&
8535  cast<CXXDeductionGuideDecl>(Best->Function)->isExplicit()) {
8536  bool IsDeductionGuide = !Best->Function->isImplicit();
8537  Diag(Kind.getLocation(), diag::err_deduced_class_template_explicit)
8538  << TemplateName << IsDeductionGuide;
8539  Diag(Best->Function->getLocation(),
8540  diag::note_explicit_ctor_deduction_guide_here)
8541  << IsDeductionGuide;
8542  return QualType();
8543  }
8544 
8545  // Make sure we didn't select an unusable deduction guide, and mark it
8546  // as referenced.
8547  DiagnoseUseOfDecl(Best->Function, Kind.getLocation());
8548  MarkFunctionReferenced(Kind.getLocation(), Best->Function);
8549  break;
8550  }
8551 
8552  // C++ [dcl.type.class.deduct]p1:
8553  // The placeholder is replaced by the return type of the function selected
8554  // by overload resolution for class template deduction.
8555  return SubstAutoType(TSInfo->getType(), Best->Function->getReturnType());
8556 }
unsigned getNumElements() const
Definition: Type.h:2822
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.
llvm::iterator_range< base_class_iterator > base_class_range
Definition: DeclCXX.h:733
Represents a single C99 designator.
Definition: Expr.h:4150
Perform a derived-to-base cast, producing an lvalue.
Defines the clang::ASTContext interface.
unsigned getNumInits() const
Definition: Expr.h:3878
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
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
Definition: Expr.h:409
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:6147
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1618
InitListExpr * WrappingSyntacticList
When Kind = SK_RewrapInitList, the syntactic form of the wrapping list.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchers.h:1510
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.
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:7422
ArrayRef< NamedDecl * >::const_iterator chain_iterator
Definition: Decl.h:2611
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:616
bool isConstantArrayType() const
Definition: Type.h:5754
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:212
DesignatorKind getKind() const
Definition: Designator.h:69
Simple class containing the result of Sema::CorrectTypo.
base_class_range bases()
Definition: DeclCXX.h:737
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:1694
step_iterator step_end() const
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2275
void setFromType(QualType T)
Definition: Overload.h:215
Produce an Objective-C object pointer.
A cast other than a C-style cast.
Definition: Sema.h:9130
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1054
QualType getCallResultType() const
Determine the type of an expression that calls this function.
Definition: Decl.h:2121
void AddOCLZeroEventStep(QualType T)
Add a step to initialize an OpenCL event_t from a NULL constant.
Definition: SemaInit.cpp:3382
Initializing char array with wide string literal.
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:258
Perform an implicit conversion sequence without narrowing.
An initialization that "converts" an Objective-C object (not a point to an object) to another Objecti...
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2954
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:232
InvalidICRKind
The non-zero enum values here are indexes into diagnostic alternatives.
Definition: SemaInit.cpp:4866
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
Definition: SemaExpr.cpp:6124
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:2761
CanQualType Char32Ty
Definition: ASTContext.h:970
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2618
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1804
const LangOptions & getLangOpts() const
Definition: Sema.h:1166
void NoteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &){return true;})
PrintOverloadCandidates - When overload resolution fails, prints diagnostic messages containing the c...
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:4287
Perform a qualification conversion, producing an rvalue.
bool allowConstDefaultInit() const
Determine whether declaring a const variable with this type is ok per core issue 253.
Definition: DeclCXX.h:1362
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
Definition: Overload.h:130
SmallVectorImpl< Step >::const_iterator step_iterator
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
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:4309
unsigned getIntWidth(QualType T) const
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:4566
static OverloadingResult TryRefInitWithConversionFunction(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, Expr *Initializer, bool AllowRValues, bool IsLValueRef, InitializationSequence &Sequence)
Try a reference initialization that involves calling a conversion function.
Definition: SemaInit.cpp:4065
static DesignatedInitExpr * CloneDesignatedInitExpr(Sema &SemaRef, DesignatedInitExpr *DIE)
Definition: SemaInit.cpp:1992
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
bool isRecordType() const
Definition: Type.h:5769
UserDefinedConversionSequence UserDefined
When ConversionKind == UserDefinedConversion, provides the details of the user-defined conversion seq...
Definition: Overload.h:430
ConstructorInfo getConstructorInfo(NamedDecl *ND)
Definition: Overload.h:864
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1243
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:81
unsigned size() const
Returns the number of designators in this initializer.
Definition: Expr.h:4275
uintptr_t Base
When Kind == EK_Base, the base specifier that provides the base class.
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Definition: Expr.h:4514
static bool canPerformArrayCopy(const InitializedEntity &Entity)
Determine whether we can perform an elementwise array copy for this kind of entity.
Definition: SemaInit.cpp:5089
void setType(QualType t)
Definition: Expr.h:128
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
Definition: Sema.h:9246
Not a narrowing conversion.
Definition: Overload.h:116
llvm::iterator_range< conversion_iterator > getVisibleConversionFunctions()
Get all conversion functions visible in current class, including conversion function templates...
Definition: DeclCXX.cpp:1293
bool hasFlexibleArrayMember() const
Definition: Decl.h:3406
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1662
bool CanPerformCopyInitialization(const InitializedEntity &Entity, ExprResult Init)
Definition: SemaInit.cpp:8265
std::string getAsString() const
Definition: Type.h:942
PtrTy get() const
Definition: Ownership.h:163
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:4312
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:1303
bool isInStdNamespace() const
Definition: DeclBase.cpp:327
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:4970
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
Definition: ASTContext.h:2241
The entity being initialized is a variable.
QualType getRecordType(const RecordDecl *Decl) const
InitListExpr * getSyntacticForm() const
Definition: Expr.h:3998
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2497
const Expr * getInit() const
Definition: Decl.h:1146
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:461
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:45
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1177
Overloading for a user-defined conversion failed.
Ambiguous candidates found.
Definition: Overload.h:43
A container of type source information.
Definition: Decl.h:62
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:3172
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:403
static bool TryInitializerListConstruction(Sema &S, InitListExpr *List, QualType DestType, InitializationSequence &Sequence, bool TreatUnavailableAsInvalid)
When initializing from init list via constructor, handle initialization of an object of type std::ini...
Definition: SemaInit.cpp:3483
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2329
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:2876
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:3946
bool isSpelledAsLValue() const
Definition: Type.h:2377
SourceLocation getDotLoc() const
Definition: Designator.h:79
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
Definition: SemaExpr.cpp:13482
bool isVariableLengthArrayNew() const
Determine whether this is an array new with an unknown bound.
const llvm::APInt & getSize() const
Definition: Type.h:2568
DeclarationName getCXXDeductionGuideName(TemplateDecl *TD)
Returns the name of a C++ deduction guide for the given template.
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:6063
Initialize an OpenCL sampler from an integer.
EntityKind getKind() const
Determine the kind of initialization.
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a base class subobject.
Definition: SemaInit.cpp:2899
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic, and whose semantics are that of the sole contained initializer)?
Definition: Expr.cpp:1879
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10497
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:758
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
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:4676
void AddCAssignmentStep(QualType T)
Add a C assignment step.
Definition: SemaInit.cpp:3306
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
Definition: Sema.h:495
Array initialization by elementwise copy.
DiagnosticsEngine & Diags
Definition: Sema.h:307
const Expr * getCallee() const
Definition: Expr.h:2246
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
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:905
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:3912
Represents a C++17 deduced template specialization type.
Definition: Type.h:4241
void resizeInits(const ASTContext &Context, unsigned NumInits)
Specify the number of initializers.
Definition: Expr.cpp:1839
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1924
void setInit(unsigned Init, Expr *expr)
Definition: Expr.h:3906
Expr * IgnoreImplicit() LLVM_READONLY
IgnoreImplicit - Skip past any implicit AST nodes which might surround this expression.
Definition: Expr.h:731
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:548
step_iterator step_begin() const
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Definition: DeclCXX.cpp:2029
SourceLocation getThrowLoc() const
Determine the location of the 'throw' keyword when initializing an exception object.
void setBegin(SourceLocation b)
Perform a derived-to-base cast, producing an rvalue.
void AddReferenceBindingStep(QualType T, bool BindingTemporary)
Add a new step binding a reference to an object.
Definition: SemaInit.cpp:3196
static InitializationKind CreateDirectList(SourceLocation InitLoc)
bool allowsNRVO() const
Determine whether this initialization allows the named return value optimization, which also applies ...
Definition: SemaInit.cpp:2980
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:1434
bool isImplicitMemberInitializer() const
Is this the implicit initialization of a member of a class from a defaulted constructor?
The entity being initialized is a temporary object.
bool isObjCRetainableType() const
Definition: Type.cpp:3751
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:3209
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isUnionType() const
Definition: Type.cpp:390
Expr * getArrayIndex(const Designator &D) const
Definition: Expr.cpp:3732
bool isVoidType() const
Definition: Type.h:5906
bool allowExplicitConversionFunctionsInRefBinding() const
Retrieve whether this initialization allows the use of explicit conversion functions when binding a r...
bool isLValue() const
Definition: Expr.h:349
The collection of all-type qualifiers we support.
Definition: Type.h:118
static void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr, bool IsReturnStmt)
Provide warnings when std::move is used on construction.
Definition: SemaInit.cpp:6284
Non-const lvalue reference binding to a vector element.
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, AssignmentAction Action, bool AllowExplicit=false)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType...
CanQualType OCLSamplerTy
Definition: ASTContext.h:987
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:2847
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:3354
Represents a C99 designated initializer expression.
Definition: Expr.h:4075
bool isOpenCLSpecificType() const
Definition: Type.h:5864
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.
static void CheckForNullPointerDereference(Sema &S, const Expr *E)
Definition: SemaInit.cpp:6383
bool isScalarType() const
Definition: Type.h:5941
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
Expr * getSubExpr(unsigned Idx) const
Definition: Expr.h:4323
Step
Definition: OpenMPClause.h:137
static bool isExprAnUnaddressableFunction(Sema &S, const Expr *E)
Tries to get a FunctionDecl out of E.
Definition: SemaInit.cpp:5078
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:3396
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init.ref]).
Definition: SemaInit.cpp:3107
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1146
A C-style cast.
Definition: Sema.h:9126
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...
static void TryConstructorInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType DestType, QualType DestArrayType, 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:3604
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:5721
QualType getReturnType() const
Definition: Decl.h:2106
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:2366
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:998
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:4369
SourceLocation getReturnLoc() const
Determine the location of the 'return' keyword when initializing the result of a function call...
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:4854
bool isPRValue() const
Definition: Expr.h:352
static void warnOnLifetimeExtension(Sema &S, const InitializedEntity &Entity, const Expr *Init, bool IsInitializerList, const ValueDecl *ExtendingDecl)
Definition: SemaInit.cpp:6244
Rewrap the single-element initializer list for a reference.
unsigned getCVRQualifiers() const
Definition: Type.h:259
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2103
void AddOCLSamplerInitStep(QualType T)
Add a step to initialize an OpenCL sampler from an integer constant.
Definition: SemaInit.cpp:3375
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:9494
bool refersToVectorElement() const
Returns whether this expression refers to a vector element.
Definition: Expr.cpp:3412
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:3411
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:1295
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2128
SourceLocation getRParenLoc() const
Definition: Expr.h:2342
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:91
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:106
Perform initialization via a constructor taking a single std::initializer_list argument.
Describes an C or C++ initializer list.
Definition: Expr.h:3848
llvm::SmallVector< QualType, 4 > CurrentParameterCopyTypes
Stack of types that correspond to the parameter entities that are currently being copy-initialized...
Definition: Sema.h:1128
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
Definition: SemaExpr.cpp:52
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2424
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1585
Represents the results of name lookup.
Definition: Lookup.h:32
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, bool SecondStepOfCopyInit=false)
Definition: SemaInit.cpp:3531
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:643
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
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:1964
const LangOptions & getLangOpts() const
Definition: ASTContext.h:659
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:537
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.
Definition: Sema.h:9500
unsigned getMinRequiredArguments() const
getMinRequiredArguments - Returns the minimum number of arguments needed to call this function...
Definition: Decl.cpp:2899
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:2018
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:1914
An x-value expression is a reference to an object with independent storage but which can be "moved"...
Definition: Specifiers.h:115
field_range fields() const
Definition: Decl.h:3483
InitializationSequence(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, bool TopLevelOfInitList=false, bool TreatUnavailableAsInvalid=true)
Try to perform initialization of the given entity, creating a record of the steps required to perform...
Definition: SemaInit.cpp:5065
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:77
SourceLocation getRBraceLoc() const
Definition: Expr.h:3991
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:148
Variable-length array must not have an initializer.
RecordDecl * getDecl() const
Definition: Type.h:3793
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:152
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:9122
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:1784
A narrowing conversion, because a constant expression got narrowed.
Definition: Overload.h:122
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:3345
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2399
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:6432
chain_iterator chain_begin() const
Definition: Decl.h:2616
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1118
The entity being initialized is an element of a vector.
bool isAmbiguous() const
Determine whether this initialization failed due to an ambiguity.
Definition: SemaInit.cpp:3118
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2701
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1930
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1134
bool hasConst() const
Definition: Type.h:237
AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, DeclAccessPair FoundDecl, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp=false)
Checks access to a constructor.
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...
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
Definition: SemaExpr.cpp:633
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
Definition: SemaExpr.cpp:7789
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:5781
detail::InMemoryDirectory::const_iterator I
The entity being initialized is a function parameter.
QualType getType() const
Definition: Decl.h:589
bool isInvalid() const
bool isUnnamedBitfield() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:2440
static void diagnoseListInit(Sema &S, const InitializedEntity &Entity, InitListExpr *InitList)
Definition: SemaInit.cpp:7386
field_iterator field_end() const
Definition: Decl.h:3486
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type...
Definition: Type.h:6091
DeclAccessPair FoundDecl
Definition: Overload.h:857
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
Definition: SemaInit.cpp:6413
CXXConstructorDecl * findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor, ConstructorUsingShadowDecl *DerivedShadow)
Given a derived-class using shadow declaration for a constructor and the correspnding base class cons...
bool isUnion() const
Definition: Decl.h:3028
Perform an implicit conversion sequence.
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3245
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2525
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:269
void setField(FieldDecl *FD)
Definition: Expr.h:4212
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:3603
A functional-style cast.
Definition: Sema.h:9128
void AddObjCObjectConversionStep(QualType T)
Add an Objective-C object conversion step, which is always a no-op.
Definition: SemaInit.cpp:3320
Non-const lvalue reference binding to a bit-field.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1028
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...
CastKind
CastKind - The kind of operation required for a conversion.
The return type of classify().
Definition: Expr.h:300
void AddStdInitializerListConstructionStep(QualType T)
Add a step to construct a std::initializer_list object from an initializer list.
Definition: SemaInit.cpp:3368
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Stmt.cpp:270
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1698
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:516
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.
NamedDecl * getDecl() const
ASTContext * Context
A narrowing conversion by virtue of the source and destination types.
Definition: Overload.h:119
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:244
SourceLocation getEllipsisLoc() const
Definition: Designator.h:121
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.
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.h:2520
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:1740
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:1979
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.h:4251
llvm::MutableArrayRef< Designator > designators()
Definition: Expr.h:4278
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:580
Expr - This represents one expression.
Definition: Expr.h:105
void setRBraceLoc(SourceLocation Loc)
Definition: Expr.h:3992
bool isQueueT() const
Definition: Type.h:5845
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:3713
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:103
bool isAnyComplexType() const
Definition: Type.h:5775
Scalar initialized from a parenthesized initializer list.
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: ExprCXX.h:3990
StandardConversionSequence After
After - Represents the standard conversion that occurs after the actual user-defined conversion...
Definition: Overload.h:280
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:4002
Represents a C++ functional cast expression that builds a temporary object.
Definition: ExprCXX.h:1469
SourceLocation getLBraceLoc() const
Definition: Expr.h:3989
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:6191
Inits[]
Definition: OpenMPClause.h:136
bool isAtomicType() const
Definition: Type.h:5794
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2551
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:3361
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:800
Passing zero to a function where OpenCL event_t is expected.
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:13138
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:1920
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2088
SourceLocation getEqualOrColonLoc() const
Retrieve the location of the '=' that precedes the initializer value itself, if present.
Definition: Expr.h:4300
Resolve the address of an overloaded function to a specific function declaration. ...
Expr * getArrayRangeStart(const Designator &D) const
Definition: Expr.cpp:3737
DeclContext * getDeclContext()
Definition: DeclBase.h:416
Overload resolution succeeded.
Definition: Overload.h:41
The entity being initialized is an exception object that is being thrown.
bool isFloatingType() const
Definition: Type.cpp:1821
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:12890
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
Definition: SemaExpr.cpp:15541
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:374
Represents a C++ template name within the type system.
Definition: TemplateName.h:176
Ref_Related - The two types are reference-related, which means that their unqualified forms (T1 and T...
Definition: Sema.h:9498
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.
ReferenceCompareResult
ReferenceCompareResult - Expresses the result of comparing two types (cv1 T1 and cv2 T2) to determine...
Definition: Sema.h:9491
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7107
Defines the clang::TypeLoc interface and its subclasses.
Floating-integral conversions (C++ 4.9)
Definition: Overload.h:73
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:699
bool isExplicit() const
Whether this function is explicit.
Definition: DeclCXX.h:2438
ObjCMethodDecl * getMethodDecl() const
Retrieve the ObjectiveC method being initialized.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1797
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
Definition: Expr.h:419
StandardConversionSequence Standard
When ConversionKind == StandardConversion, provides the details of the standard conversion sequence...
Definition: Overload.h:426
static void TryDefaultInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitializationSequence &Sequence)
Attempt default initialization (C++ [dcl.init]p6).
Definition: SemaInit.cpp:4635
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.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1714
Represents a GCC generic vector type.
Definition: Type.h:2797
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:4254
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2407
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
const IdentifierInfo * getField() const
Definition: Designator.h:74
FailureKind getFailureKind() const
Determine why initialization failed.
ValueDecl * getDecl()
Definition: Expr.h:1038
bool isGLValue() const
Definition: Expr.h:251
QualType getElementType() const
Definition: Type.h:2821
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2605
void AddStringInitStep(QualType T)
Add a string init step.
Definition: SemaInit.cpp:3313
The result type of a method or function.
InitKind getKind() const
Determine the initialization kind.
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c.h:82
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:1463
void AddZeroInitializationStep(QualType T)
Add a zero-initialization step.
Definition: SemaInit.cpp:3299
bool hasUninitializedReferenceMember() const
Whether this class or any of its subobjects has any members of reference type which would make value-...
Definition: DeclCXX.h:1197
static void TryReferenceListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitListExpr *InitList, InitializationSequence &Sequence, bool TreatUnavailableAsInvalid)
Attempt list initialization of a reference.
Definition: SemaInit.cpp:3795
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:4321
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
InitListExpr * getUpdater() const
Definition: Expr.h:4427
FailureKind
Describes why initialization failed.
A narrowing conversion, because a non-constant-expression variable might have got narrowed...
Definition: Overload.h:126
bool isArrayRangeDesignator() const
Definition: Expr.h:4200
Lvalue-to-rvalue conversion (C++ 4.1)
Definition: Overload.h:62
List initialization failed at some point.
SourceLocation getEndLoc() const
Get the end source location.
Definition: TypeLoc.cpp:206
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:400
Perform a conversion adding _Atomic to a type.
void AddListInitializationStep(QualType T)
Add a list-initialization step.
Definition: SemaInit.cpp:3278
SourceLocation getDotLoc() const
Definition: Expr.h:4217
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, 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...
CanQualType OverloadTy
Definition: ASTContext.h:979
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:222
CXXConstructorDecl * Constructor
Definition: Overload.h:858
const Decl * FoundDecl
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:3751
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:865
Perform a qualification conversion, producing an lvalue.
Integral conversions (C++ 4.7)
Definition: Overload.h:70
void AddLValueToRValueStep(QualType Ty)
Add a new step that performs a load of the given type.
Definition: SemaInit.cpp:3258
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:387
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5956
Expr * getArrayRangeEnd(const Designator &D) const
Definition: Expr.cpp:3743
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Definition: Overload.h:624
SequenceKind
Describes the kind of initialization sequence computed.
Array indexing for initialization by elementwise copy.
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:2878
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5489
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3810
Reference initialization from an initializer list.
QualType getElementType() const
Definition: Type.h:2176
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:1661
static bool shouldBindAsTemporary(const InitializedEntity &Entity)
Whether we should bind a created object as a temporary when initializing the given entity...
Definition: SemaInit.cpp:5515
SourceLocation getLocation() const
Retrieve the location at which initialization is occurring.
bool ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&SrcExpr, bool Diagnose=true)
Definition: SemaExpr.cpp:12836
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:4204
QualType DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Init)
Definition: SemaInit.cpp:8342
bool isValid() const
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.
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, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
ASTContext & getASTContext() const
Definition: Sema.h:1173
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:1162
void setReferenced(bool R=true)
Definition: DeclBase.h:567
VectorKind getVectorKind() const
Definition: Type.h:2830
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
VD Variable
When Kind == EK_Variable, EK_Member or EK_Binding, the variable.
static InitializedEntity InitializeElement(ASTContext &Context, unsigned Index, const InitializedEntity &Parent)
Create the initialization entity for an array element.
QualType withConst() const
Definition: Type.h:782
static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e, bool isAddressOf, bool &isWeakAccess)
Determines whether this expression is an acceptable ICR source.
Definition: SemaInit.cpp:4869
bool isExplicitCast() const
Determine whether this initialization is an explicit cast.
const Designator & getDesignator(unsigned Idx) const
Definition: Designator.h:194
void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, Expr *From, QualType ToType, OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit)
Adds a conversion function template specialization candidate to the overload set, using template argu...
const InitializedEntity * getParent() const
Retrieve the parent of the entity being initialized, when the initialization itself is occurring with...
Initialization of some unused destination type with an initializer list.
The entity being initialized is the result of a function call.
void InitializeFrom(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, bool TopLevelOfInitList, bool TreatUnavailableAsInvalid)
Definition: SemaInit.cpp:5123
SourceLocation getLBracketLoc() const
Definition: Expr.h:4227
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:2235
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:3211
Specifies that a value-dependent expression should be considered to never be a null pointer constant...
Definition: Expr.h:703
CanQualType VoidTy
Definition: ASTContext.h:963
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:1843
Describes the kind of initialization being performed, along with location information for tokens rela...
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
Definition: SemaExpr.cpp:7737
static bool hasCopyOrMoveCtorParam(ASTContext &Ctx, const ConstructorInfo &Info)
Determine if the constructor has the signature of a copy or move constructor for the type T of the cl...
Definition: SemaInit.cpp:3517
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:6000
void setAsIdentityConversion()
StandardConversionSequence - Set the standard conversion sequence to the identity conversion...
Reference initialized from a parenthesized initializer list.
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:5879
static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc, QualType T)
Somewhere within T there is an uninitialized reference subobject.
Definition: SemaInit.cpp:7330
bool isRValue() const
Definition: Expr.h:353
bool isRValue() const
Definition: Expr.h:249
Expr ** getInits()
Retrieve the set of initializers.
Definition: Expr.h:3881
Overloading for initialization by constructor failed.
QualType getToType(unsigned Idx) const
Definition: Overload.h:229
static bool ResolveOverloadedFunctionForReferenceBinding(Sema &S, Expr *Initializer, QualType &SourceType, QualType &UnqualifiedSourceType, QualType UnqualifiedTargetType, InitializationSequence &Sequence)
Definition: SemaInit.cpp:3751
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:166
An optional copy of a temporary object to another temporary object, which is permitted (but not requi...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1507
void AddOCLZeroQueueStep(QualType T)
Add a step to initialize an OpenCL queue_t from 0.
Definition: SemaInit.cpp:3389
static DesignatedInitExpr * Create(const ASTContext &C, llvm::ArrayRef< Designator > Designators, ArrayRef< Expr * > IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)
Definition: Expr.cpp:3677
bool isVectorType() const
Definition: Type.h:5778
void AddAtomicConversionStep(QualType Ty)
Add a new step that performs conversion from non-atomic to atomic type.
Definition: SemaInit.cpp:3251
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2325
void AddArrayInitStep(QualType T, bool IsGNUExtension)
Add an array initialization step.
Definition: SemaInit.cpp:3327
void AddPassByIndirectCopyRestoreStep(QualType T, bool shouldCopy)
Add a step to pass an object by indirect copy-restore.
Definition: SemaInit.cpp:3352
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1902
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5559
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:724
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:3942
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:732
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
Definition: Expr.h:434
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:262
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:70
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.cpp:1627
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
bool isFunctionProtoType() const
Definition: Type.h:1684
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD)
getSpecialMember - get the special member enum for a method.
Definition: SemaDecl.cpp:2735
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:4653
void SetFailed(FailureKind Failure)
Note that this initialization sequence failed.
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:1496
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:127
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
Definition: SemaInit.cpp:8280
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 bool isInvalid(LocType Loc, bool *Invalid)
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:1906
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:1216
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:2126
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:401
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:2593
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:4954
static bool isNonReferenceableGLValue(Expr *E)
Determine whether an expression is a non-referenceable glvalue (one to which a reference can never bi...
Definition: SemaInit.cpp:4282
bool isXValue() const
Definition: Expr.h:350
SourceRange getSourceRange(const SourceRange &Range)
Returns the SourceRange of a SourceRange.
Definition: FixIt.h:34
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:4936
bool isInvalidDecl() const
Definition: DeclBase.h:532
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2594
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:6022
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
Definition: SemaExpr.cpp:14794
bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:203
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:116
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.
ValueDecl * getDecl() const
Retrieve the variable, parameter, or field being initialized.
Definition: SemaInit.cpp:2949
DeclarationName - The name of a declaration.
chain_iterator chain_end() const
Definition: Decl.h:2617
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 any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:367
std::string getAsString(ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:545
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:683
StringKind getKind() const
Definition: Expr.h:1594
Requests that only viable candidates be shown.
Definition: Overload.h:53
Array initialization (from an array rvalue) as a GNU extension.
detail::InMemoryDirectory::const_iterator E
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7328
bool usesGNUSyntax() const
Determines whether this designated initializer used the deprecated GNU syntax for designated initiali...
Definition: Expr.h:4305
bool isSamplerT() const
Definition: Type.h:5833
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2263
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2087
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:5631
bool isLValueReferenceType() const
Definition: Type.h:5724
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:1300
bool isParameterKind() const
void setInitializedFieldInUnion(FieldDecl *FD)
Definition: Expr.h:3966
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:1557
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2486
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
Definition: SemaDecl.cpp:1155
bool isRValueReferenceType() const
Definition: Type.h:5727
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:5662
static bool isRValueRef(QualType ParamType)
Definition: Consumed.cpp:177
bool isObjCObjectType() const
Definition: Type.h:5787
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:849
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3784
void setAllToTypes(QualType T)
Definition: Overload.h:220
Complex values, per C99 6.2.5p11.
Definition: Type.h:2164
static bool TryOCLZeroEventInitialization(Sema &S, InitializationSequence &Sequence, QualType DestType, Expr *Initializer)
Definition: SemaInit.cpp:5038
SourceManager & getSourceManager() const
Definition: Sema.h:1171
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:6042
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:3728
QualType getCanonicalType() const
Definition: Type.h:5528
Array must be initialized with an initializer list.
static bool shouldDestroyEntity(const InitializedEntity &Entity)
Whether the given entity, when initialized with an object created for that initialization, requires destruction.
Definition: SemaInit.cpp:5546
The entity being initialized is a structured binding of a decomposition declaration.
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:7369
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
CanQualType DependentTy
Definition: ASTContext.h:979
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1326
bool isFunctionType() const
Definition: Type.h:5709
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
Definition: SemaInit.cpp:6398
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1303
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2360
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1634
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1240
LValueClassification
Definition: Expr.h:253
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1548
void AddArrayInitLoopStep(QualType T, QualType EltTy)
Add an array initialization loop step.
Definition: SemaInit.cpp:3334
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, Expr *ArgExpr, DeclAccessPair FoundDecl)
Checks access to an overloaded member operator, including conversion operators.
unsigned getAddressSpace() const
Definition: Type.h:335
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:1909
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:90
void AddDerivedToBaseCastStep(QualType BaseType, ExprValueKind Category)
Add a new step in the initialization that performs a derived-to- base cast.
Definition: SemaInit.cpp:3184
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
void setExprNeedsCleanups(bool SideEffects)
Definition: CleanupInfo.h:29
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
Represents a base class of a C++ class.
Definition: DeclCXX.h:158
bool isInitListConstructor(const FunctionDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init.list]p2.
static bool TryOCLSamplerInitialization(Sema &S, InitializationSequence &Sequence, QualType DestType, Expr *Initializer)
Definition: SemaInit.cpp:5017
QualType getType() const
Retrieve type being initialized.
void DiscardMisalignedMemberAddress(const Type *T, Expr *E)
This function checks if the expression is in the sef of potentially misaligned members and it is conv...
static SourceLocation getInitializationLoc(const InitializedEntity &Entity, Expr *Initializer)
Get the location at which initialization diagnostics should appear.
Definition: SemaInit.cpp:5576
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2009
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...
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
An implicit conversion.
Definition: Sema.h:9124
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:149
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:3219
Direct-initialization from a reference-related object in the final stage of class copy-initialization...
bool hasAddressSpace() const
Definition: Type.h:334
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
static void TryListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, InitListExpr *InitList, InitializationSequence &Sequence, bool TreatUnavailableAsInvalid)
Attempt list initialization (C++0x [dcl.init.list])
Definition: SemaInit.cpp:3869
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:4548
void dump() const
Dump a representation of the initialized entity to standard error, for debugging purposes.
Definition: SemaInit.cpp:3053
Describes the sequence of initializations required to initialize a given object or reference with a s...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5569
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
Definition: Expr.h:3952
Represents a C++ struct/union/class.
Definition: DeclCXX.h:267
Compatible - the types are compatible according to the standard.
Definition: Sema.h:9248
Perform initialization via a constructor, taking arguments from a single InitListExpr.
Represents a loop initializing the elements of an array.
Definition: Expr.h:4459
bool isObjCObjectPointerType() const
Definition: Type.h:5784
Represents a C array with an unspecified size.
Definition: Type.h:2603
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
The entity being initialized is a field of block descriptor for the copied-in lambda object that's us...
CanQualType Char16Ty
Definition: ASTContext.h:969
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:317
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:4557
A dependent initialization, which could not be type-checked due to the presence of dependent types or...
bool isEventT() const
Definition: Type.h:5837
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:2084
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:245
bool isArrayType() const
Definition: Type.h:5751
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:1506
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2206
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1414
Designator * getDesignator(unsigned Idx)
Definition: Expr.h:4286
void setInit(Expr *init)
Definition: Expr.h:4313
ExprResult ExprError()
Definition: Ownership.h:268
DeclarationName getName() const
Retrieve the name of the entity being initialized.
Definition: SemaInit.cpp:2914
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
Definition: Expr.cpp:2679
void reserveInits(const ASTContext &C, unsigned NumInits)
Reserve space for some number of initializers.
Definition: Expr.cpp:1834
void EmitRelatedResultTypeNote(const Expr *E)
If the given expression involves a message send to a method with a related result type...
bool isBigEndian() const
Definition: TargetInfo.h:988
bool isIncompleteArrayType() const
Definition: Type.h:5757
void AddConstructorInitializationStep(DeclAccessPair FoundDecl, CXXConstructorDecl *Constructor, QualType T, bool HadMultipleCandidates, bool FromInitList, bool AsInitList)
Add a constructor-initialization step.
Definition: SemaInit.cpp:3285
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:5467
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:953
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:402
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:2531
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:3232
void AddFinalCopy(QualType T)
Add a new step that makes a copy of the input to an object of the given type, as the final step in cl...
Definition: SemaInit.cpp:3204
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5564
SourceManager & SourceMgr
Definition: Sema.h:308
void clear()
Clear out all of the candidates.
bool hasDefaultConstructor() const
Determine whether this class has any default constructors.
Definition: DeclCXX.h:874
ImplicitConversionKind First
First – The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion...
Definition: Overload.h:146
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3896
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:3960
No viable function found.
Definition: Overload.h:42
bool isConstructorInitialization() const
Determine whether this initialization is direct call to a constructor.
Definition: SemaInit.cpp:3166
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:110
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:3267
size_t size() const
Definition: Overload.h:804
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:407
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:305
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:213
void dump() const
Dump a representation of this initialization sequence to standard error, for debugging purposes...
Definition: SemaInit.cpp:8167
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2648
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:274
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:1744
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5548
static void DiagnoseNarrowingInInitList(Sema &S, const ImplicitConversionSequence &ICS, QualType PreNarrowingType, QualType EntityType, const Expr *PostInit)
Definition: SemaInit.cpp:8171
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:683
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=false, ConversionSequenceList EarlyConversions=None)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
Describes an entity that is being initialized.
void setToType(unsigned Idx, QualType T)
Definition: Overload.h:216
NamespaceDecl * getStdNamespace() const
unsigned getNumDesignators() const
Definition: Designator.h:193
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:257
AssignmentAction
Definition: Sema.h:2438
SourceLocation getFieldLoc() const
Definition: Expr.h:4222
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:5779
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:2553
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:3444
Declaration of a template function.
Definition: DeclTemplate.h:939
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4549
const NamedDecl * Result
Definition: USRFinder.cpp:70
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
static bool TryOCLZeroQueueInitialization(Sema &S, InitializationSequence &Sequence, QualType DestType, Expr *Initializer)
Definition: SemaInit.cpp:5051
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:5928
static bool maybeRecoverWithZeroInitialization(Sema &S, InitializationSequence &Sequence, const InitializedEntity &Entity)
Tries to add a zero initializer. Returns true if that worked.
Definition: SemaInit.cpp:3424
bool hasLocalStorage() const
hasLocalStorage - Returns true if a variable with function scope is a non-static local variable...
Definition: Decl.h:963
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2368
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5516
bool hasInClassInitializer() const
hasInClassInitializer - Determine whether this member has a C++11 in-class initializer.
Definition: Decl.h:2481
bool isPointerType() const
Definition: Type.h:5712
SourceRange getSourceRange() const LLVM_READONLY
Definition: Expr.h:4260
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:5854
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1).
Definition: Overload.h:141