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