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