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