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