clang  8.0.0svn
Initialization.h
Go to the documentation of this file.
1 //===- Initialization.h - Semantic Analysis for Initializers ----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file provides supporting data types for initialization of objects.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_SEMA_INITIALIZATION_H
15 #define LLVM_CLANG_SEMA_INITIALIZATION_H
16 
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/Attr.h"
19 #include "clang/AST/Decl.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/Type.h"
25 #include "clang/Basic/LLVM.h"
28 #include "clang/Basic/Specifiers.h"
29 #include "clang/Sema/Overload.h"
30 #include "clang/Sema/Ownership.h"
31 #include "llvm/ADT/ArrayRef.h"
32 #include "llvm/ADT/SmallVector.h"
33 #include "llvm/ADT/StringRef.h"
34 #include "llvm/ADT/iterator_range.h"
35 #include "llvm/Support/Casting.h"
36 #include <cassert>
37 #include <cstdint>
38 #include <string>
39 
40 namespace clang {
41 
42 class APValue;
43 class CXXBaseSpecifier;
44 class CXXConstructorDecl;
45 class ObjCMethodDecl;
46 class Sema;
47 
48 /// Describes an entity that is being initialized.
49 class alignas(8) InitializedEntity {
50 public:
51  /// Specifies the kind of entity being initialized.
52  enum EntityKind {
53  /// The entity being initialized is a variable.
55 
56  /// The entity being initialized is a function parameter.
58 
59  /// The entity being initialized is the result of a function call.
61 
62  /// The entity being initialized is the result of a statement expression.
64 
65  /// The entity being initialized is an exception object that
66  /// is being thrown.
68 
69  /// The entity being initialized is a non-static data member
70  /// subobject.
72 
73  /// The entity being initialized is an element of an array.
75 
76  /// The entity being initialized is an object (or array of
77  /// objects) allocated via new.
79 
80  /// The entity being initialized is a temporary object.
82 
83  /// The entity being initialized is a base member subobject.
85 
86  /// The initialization is being done by a delegating constructor.
88 
89  /// The entity being initialized is an element of a vector.
90  /// or vector.
92 
93  /// The entity being initialized is a field of block descriptor for
94  /// the copied-in c++ object.
96 
97  /// The entity being initialized is a field of block descriptor for the
98  /// copied-in lambda object that's used in the lambda to block conversion.
100 
101  /// The entity being initialized is the real or imaginary part of a
102  /// complex number.
104 
105  /// The entity being initialized is the field that captures a
106  /// variable in a lambda.
108 
109  /// The entity being initialized is the initializer for a compound
110  /// literal.
112 
113  /// The entity being implicitly initialized back to the formal
114  /// result type.
116 
117  /// The entity being initialized is a function parameter; function
118  /// is member of group of audited CF APIs.
120 
121  /// The entity being initialized is a structured binding of a
122  /// decomposition declaration.
124 
125  // Note: err_init_conversion_failed in DiagnosticSemaKinds.td uses this
126  // enum as an index for its first %select. When modifying this list,
127  // that diagnostic text needs to be updated as well.
128  };
129 
130 private:
131  /// The kind of entity being initialized.
133 
134  /// If non-NULL, the parent entity in which this
135  /// initialization occurs.
136  const InitializedEntity *Parent = nullptr;
137 
138  /// The type of the object or reference being initialized.
139  QualType Type;
140 
141  /// The mangling number for the next reference temporary to be created.
142  mutable unsigned ManglingNumber = 0;
143 
144  struct LN {
145  /// When Kind == EK_Result, EK_Exception, EK_New, the
146  /// location of the 'return', 'throw', or 'new' keyword,
147  /// respectively. When Kind == EK_Temporary, the location where
148  /// the temporary is being created.
149  unsigned Location;
150 
151  /// Whether the entity being initialized may end up using the
152  /// named return value optimization (NRVO).
153  bool NRVO;
154  };
155 
156  struct VD {
157  /// The VarDecl, FieldDecl, or BindingDecl being initialized.
158  ValueDecl *VariableOrMember;
159 
160  /// When Kind == EK_Member, whether this is an implicit member
161  /// initialization in a copy or move constructor. These can perform array
162  /// copies.
163  bool IsImplicitFieldInit;
164 
165  /// When Kind == EK_Member, whether this is the initial initialization
166  /// check for a default member initializer.
167  bool IsDefaultMemberInit;
168  };
169 
170  struct C {
171  /// The name of the variable being captured by an EK_LambdaCapture.
172  IdentifierInfo *VarID;
173 
174  /// The source location at which the capture occurs.
175  unsigned Location;
176  };
177 
178  union {
179  /// When Kind == EK_Variable, EK_Member or EK_Binding, the variable.
181 
182  /// When Kind == EK_RelatedResult, the ObjectiveC method where
183  /// result type was implicitly changed to accommodate ARC semantics.
185 
186  /// When Kind == EK_Parameter, the ParmVarDecl, with the
187  /// low bit indicating whether the parameter is "consumed".
189 
190  /// When Kind == EK_Temporary or EK_CompoundLiteralInit, the type
191  /// source information for the temporary.
193 
194  struct LN LocAndNRVO;
195 
196  /// When Kind == EK_Base, the base specifier that provides the
197  /// base class. The lower bit specifies whether the base is an inherited
198  /// virtual base.
200 
201  /// When Kind == EK_ArrayElement, EK_VectorElement, or
202  /// EK_ComplexElement, the index of the array or vector element being
203  /// initialized.
204  unsigned Index;
205 
206  struct C Capture;
207  };
208 
209  InitializedEntity() = default;
210 
211  /// Create the initialization entity for a variable.
213  : Kind(EK), Type(Var->getType()), Variable{Var, false, false} {}
214 
215  /// Create the initialization entity for the result of a
216  /// function, throwing an object, performing an explicit cast, or
217  /// initializing a parameter for which there is no declaration.
219  bool NRVO = false)
220  : Kind(Kind), Type(Type) {
221  LocAndNRVO.Location = Loc.getRawEncoding();
222  LocAndNRVO.NRVO = NRVO;
223  }
224 
225  /// Create the initialization entity for a member subobject.
226  InitializedEntity(FieldDecl *Member, const InitializedEntity *Parent,
227  bool Implicit, bool DefaultMemberInit)
228  : Kind(EK_Member), Parent(Parent), Type(Member->getType()),
229  Variable{Member, Implicit, DefaultMemberInit} {}
230 
231  /// Create the initialization entity for an array element.
232  InitializedEntity(ASTContext &Context, unsigned Index,
233  const InitializedEntity &Parent);
234 
235  /// Create the initialization entity for a lambda capture.
237  : Kind(EK_LambdaCapture), Type(FieldType) {
238  Capture.VarID = VarID;
239  Capture.Location = Loc.getRawEncoding();
240  }
241 
242 public:
243  /// Create the initialization entity for a variable.
245  return InitializedEntity(Var);
246  }
247 
248  /// Create the initialization entity for a parameter.
250  const ParmVarDecl *Parm) {
251  return InitializeParameter(Context, Parm, Parm->getType());
252  }
253 
254  /// Create the initialization entity for a parameter, but use
255  /// another type.
257  const ParmVarDecl *Parm,
258  QualType Type) {
259  bool Consumed = (Context.getLangOpts().ObjCAutoRefCount &&
260  Parm->hasAttr<NSConsumedAttr>());
261 
262  InitializedEntity Entity;
263  Entity.Kind = EK_Parameter;
264  Entity.Type =
266  Entity.Parent = nullptr;
267  Entity.Parameter
268  = (static_cast<uintptr_t>(Consumed) | reinterpret_cast<uintptr_t>(Parm));
269  return Entity;
270  }
271 
272  /// Create the initialization entity for a parameter that is
273  /// only known by its type.
275  QualType Type,
276  bool Consumed) {
277  InitializedEntity Entity;
278  Entity.Kind = EK_Parameter;
279  Entity.Type = Context.getVariableArrayDecayedType(Type);
280  Entity.Parent = nullptr;
281  Entity.Parameter = (Consumed);
282  return Entity;
283  }
284 
285  /// Create the initialization entity for the result of a function.
287  QualType Type, bool NRVO) {
288  return InitializedEntity(EK_Result, ReturnLoc, Type, NRVO);
289  }
290 
292  QualType Type) {
293  return InitializedEntity(EK_StmtExprResult, ReturnLoc, Type);
294  }
295 
297  QualType Type, bool NRVO) {
298  return InitializedEntity(EK_BlockElement, BlockVarLoc, Type, NRVO);
299  }
300 
302  QualType Type, bool NRVO) {
304  BlockVarLoc, Type, NRVO);
305  }
306 
307  /// Create the initialization entity for an exception object.
309  QualType Type, bool NRVO) {
310  return InitializedEntity(EK_Exception, ThrowLoc, Type, NRVO);
311  }
312 
313  /// Create the initialization entity for an object allocated via new.
315  return InitializedEntity(EK_New, NewLoc, Type);
316  }
317 
318  /// Create the initialization entity for a temporary.
320  return InitializeTemporary(nullptr, Type);
321  }
322 
323  /// Create the initialization entity for a temporary.
325  return InitializeTemporary(TypeInfo, TypeInfo->getType());
326  }
327 
328  /// Create the initialization entity for a temporary.
330  QualType Type) {
332  Result.TypeInfo = TypeInfo;
333  return Result;
334  }
335 
336  /// Create the initialization entity for a related result.
338  QualType Type) {
340  Result.MethodDecl = MD;
341  return Result;
342  }
343 
344  /// Create the initialization entity for a base class subobject.
345  static InitializedEntity
347  bool IsInheritedVirtualBase,
348  const InitializedEntity *Parent = nullptr);
349 
350  /// Create the initialization entity for a delegated constructor.
353  }
354 
355  /// Create the initialization entity for a member subobject.
356  static InitializedEntity
358  const InitializedEntity *Parent = nullptr,
359  bool Implicit = false) {
360  return InitializedEntity(Member, Parent, Implicit, false);
361  }
362 
363  /// Create the initialization entity for a member subobject.
364  static InitializedEntity
366  const InitializedEntity *Parent = nullptr,
367  bool Implicit = false) {
368  return InitializedEntity(Member->getAnonField(), Parent, Implicit, false);
369  }
370 
371  /// Create the initialization entity for a default member initializer.
372  static InitializedEntity
374  return InitializedEntity(Member, nullptr, false, true);
375  }
376 
377  /// Create the initialization entity for an array element.
379  unsigned Index,
380  const InitializedEntity &Parent) {
381  return InitializedEntity(Context, Index, Parent);
382  }
383 
384  /// Create the initialization entity for a structured binding.
386  return InitializedEntity(Binding, EK_Binding);
387  }
388 
389  /// Create the initialization entity for a lambda capture.
391  QualType FieldType,
392  SourceLocation Loc) {
393  return InitializedEntity(VarID, FieldType, Loc);
394  }
395 
396  /// Create the entity for a compound literal initializer.
399  TSI->getType());
400  Result.TypeInfo = TSI;
401  return Result;
402  }
403 
404  /// Determine the kind of initialization.
405  EntityKind getKind() const { return Kind; }
406 
407  /// Retrieve the parent of the entity being initialized, when
408  /// the initialization itself is occurring within the context of a
409  /// larger initialization.
410  const InitializedEntity *getParent() const { return Parent; }
411 
412  /// Retrieve type being initialized.
413  QualType getType() const { return Type; }
414 
415  /// Retrieve complete type-source information for the object being
416  /// constructed, if known.
418  if (Kind == EK_Temporary || Kind == EK_CompoundLiteralInit)
419  return TypeInfo;
420 
421  return nullptr;
422  }
423 
424  /// Retrieve the name of the entity being initialized.
425  DeclarationName getName() const;
426 
427  /// Retrieve the variable, parameter, or field being
428  /// initialized.
429  ValueDecl *getDecl() const;
430 
431  /// Retrieve the ObjectiveC method being initialized.
433 
434  /// Determine whether this initialization allows the named return
435  /// value optimization, which also applies to thrown objects.
436  bool allowsNRVO() const;
437 
438  bool isParameterKind() const {
439  return (getKind() == EK_Parameter ||
441  }
442 
443  /// Determine whether this initialization consumes the
444  /// parameter.
445  bool isParameterConsumed() const {
446  assert(isParameterKind() && "Not a parameter");
447  return (Parameter & 1);
448  }
449 
450  /// Retrieve the base specifier.
452  assert(getKind() == EK_Base && "Not a base specifier");
453  return reinterpret_cast<const CXXBaseSpecifier *>(Base & ~0x1);
454  }
455 
456  /// Return whether the base is an inherited virtual base.
457  bool isInheritedVirtualBase() const {
458  assert(getKind() == EK_Base && "Not a base specifier");
459  return Base & 0x1;
460  }
461 
462  /// Determine whether this is an array new with an unknown bound.
464  return getKind() == EK_New && dyn_cast_or_null<IncompleteArrayType>(
466  }
467 
468  /// Is this the implicit initialization of a member of a class from
469  /// a defaulted constructor?
471  return getKind() == EK_Member && Variable.IsImplicitFieldInit;
472  }
473 
474  /// Is this the default member initializer of a member (specified inside
475  /// the class definition)?
477  return getKind() == EK_Member && Variable.IsDefaultMemberInit;
478  }
479 
480  /// Determine the location of the 'return' keyword when initializing
481  /// the result of a function call.
483  assert(getKind() == EK_Result && "No 'return' location!");
485  }
486 
487  /// Determine the location of the 'throw' keyword when initializing
488  /// an exception object.
490  assert(getKind() == EK_Exception && "No 'throw' location!");
492  }
493 
494  /// If this is an array, vector, or complex number element, get the
495  /// element's index.
496  unsigned getElementIndex() const {
497  assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement ||
499  return Index;
500  }
501 
502  /// If this is already the initializer for an array or vector
503  /// element, sets the element index.
504  void setElementIndex(unsigned Index) {
505  assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement ||
507  this->Index = Index;
508  }
509 
510  /// For a lambda capture, return the capture's name.
511  StringRef getCapturedVarName() const {
512  assert(getKind() == EK_LambdaCapture && "Not a lambda capture!");
513  return Capture.VarID->getName();
514  }
515 
516  /// Determine the location of the capture when initializing
517  /// field from a captured variable in a lambda.
519  assert(getKind() == EK_LambdaCapture && "Not a lambda capture!");
520  return SourceLocation::getFromRawEncoding(Capture.Location);
521  }
522 
525  }
526 
527  unsigned allocateManglingNumber() const { return ++ManglingNumber; }
528 
529  /// Dump a representation of the initialized entity to standard error,
530  /// for debugging purposes.
531  void dump() const;
532 
533 private:
534  unsigned dumpImpl(raw_ostream &OS) const;
535 };
536 
537 /// Describes the kind of initialization being performed, along with
538 /// location information for tokens related to the initialization (equal sign,
539 /// parentheses).
541 public:
542  /// The kind of initialization being performed.
543  enum InitKind {
544  /// Direct initialization
546 
547  /// Direct list-initialization
549 
550  /// Copy initialization
552 
553  /// Default initialization
555 
556  /// Value initialization
557  IK_Value
558  };
559 
560 private:
561  /// The context of the initialization.
562  enum InitContext {
563  /// Normal context
564  IC_Normal,
565 
566  /// Normal context, but allows explicit conversion functionss
567  IC_ExplicitConvs,
568 
569  /// Implicit context (value initialization)
570  IC_Implicit,
571 
572  /// Static cast context
573  IC_StaticCast,
574 
575  /// C-style cast context
576  IC_CStyleCast,
577 
578  /// Functional cast context
579  IC_FunctionalCast
580  };
581 
582  /// The kind of initialization being performed.
583  InitKind Kind : 8;
584 
585  /// The context of the initialization.
586  InitContext Context : 8;
587 
588  /// The source locations involved in the initialization.
589  SourceLocation Locations[3];
590 
591  InitializationKind(InitKind Kind, InitContext Context, SourceLocation Loc1,
592  SourceLocation Loc2, SourceLocation Loc3)
593  : Kind(Kind), Context(Context) {
594  Locations[0] = Loc1;
595  Locations[1] = Loc2;
596  Locations[2] = Loc3;
597  }
598 
599 public:
600  /// Create a direct initialization.
602  SourceLocation LParenLoc,
603  SourceLocation RParenLoc) {
604  return InitializationKind(IK_Direct, IC_Normal,
605  InitLoc, LParenLoc, RParenLoc);
606  }
607 
609  return InitializationKind(IK_DirectList, IC_Normal, InitLoc, InitLoc,
610  InitLoc);
611  }
612 
614  SourceLocation LBraceLoc,
615  SourceLocation RBraceLoc) {
616  return InitializationKind(IK_DirectList, IC_Normal, InitLoc, LBraceLoc,
617  RBraceLoc);
618  }
619 
620  /// Create a direct initialization due to a cast that isn't a C-style
621  /// or functional cast.
623  return InitializationKind(IK_Direct, IC_StaticCast, TypeRange.getBegin(),
624  TypeRange.getBegin(), TypeRange.getEnd());
625  }
626 
627  /// Create a direct initialization for a C-style cast.
629  SourceRange TypeRange,
630  bool InitList) {
631  // C++ cast syntax doesn't permit init lists, but C compound literals are
632  // exactly that.
633  return InitializationKind(InitList ? IK_DirectList : IK_Direct,
634  IC_CStyleCast, StartLoc, TypeRange.getBegin(),
635  TypeRange.getEnd());
636  }
637 
638  /// Create a direct initialization for a functional cast.
640  bool InitList) {
641  return InitializationKind(InitList ? IK_DirectList : IK_Direct,
642  IC_FunctionalCast, TypeRange.getBegin(),
643  TypeRange.getBegin(), TypeRange.getEnd());
644  }
645 
646  /// Create a copy initialization.
648  SourceLocation EqualLoc,
649  bool AllowExplicitConvs = false) {
650  return InitializationKind(IK_Copy,
651  AllowExplicitConvs? IC_ExplicitConvs : IC_Normal,
652  InitLoc, EqualLoc, EqualLoc);
653  }
654 
655  /// Create a default initialization.
657  return InitializationKind(IK_Default, IC_Normal, InitLoc, InitLoc, InitLoc);
658  }
659 
660  /// Create a value initialization.
662  SourceLocation LParenLoc,
663  SourceLocation RParenLoc,
664  bool isImplicit = false) {
665  return InitializationKind(IK_Value, isImplicit ? IC_Implicit : IC_Normal,
666  InitLoc, LParenLoc, RParenLoc);
667  }
668 
669  /// Create an initialization from an initializer (which, for direct
670  /// initialization from a parenthesized list, will be a ParenListExpr).
672  Expr *Init) {
673  if (!Init) return CreateDefault(Loc);
674  if (!DirectInit)
675  return CreateCopy(Loc, Init->getBeginLoc());
676  if (isa<InitListExpr>(Init))
677  return CreateDirectList(Loc, Init->getBeginLoc(), Init->getEndLoc());
678  return CreateDirect(Loc, Init->getBeginLoc(), Init->getEndLoc());
679  }
680 
681  /// Determine the initialization kind.
682  InitKind getKind() const {
683  return Kind;
684  }
685 
686  /// Determine whether this initialization is an explicit cast.
687  bool isExplicitCast() const {
688  return Context >= IC_StaticCast;
689  }
690 
691  /// Determine whether this initialization is a C-style cast.
693  return Context >= IC_CStyleCast;
694  }
695 
696  /// Determine whether this is a C-style cast.
697  bool isCStyleCast() const {
698  return Context == IC_CStyleCast;
699  }
700 
701  /// Determine whether this is a functional-style cast.
702  bool isFunctionalCast() const {
703  return Context == IC_FunctionalCast;
704  }
705 
706  /// Determine whether this initialization is an implicit
707  /// value-initialization, e.g., as occurs during aggregate
708  /// initialization.
709  bool isImplicitValueInit() const { return Context == IC_Implicit; }
710 
711  /// Retrieve the location at which initialization is occurring.
712  SourceLocation getLocation() const { return Locations[0]; }
713 
714  /// Retrieve the source range that covers the initialization.
716  return SourceRange(Locations[0], Locations[2]);
717  }
718 
719  /// Retrieve the location of the equal sign for copy initialization
720  /// (if present).
722  assert(Kind == IK_Copy && "Only copy initialization has an '='");
723  return Locations[1];
724  }
725 
726  bool isCopyInit() const { return Kind == IK_Copy; }
727 
728  /// Retrieve whether this initialization allows the use of explicit
729  /// constructors.
730  bool AllowExplicit() const { return !isCopyInit(); }
731 
732  /// Retrieve whether this initialization allows the use of explicit
733  /// conversion functions when binding a reference. If the reference is the
734  /// first parameter in a copy or move constructor, such conversions are
735  /// permitted even though we are performing copy-initialization.
737  return !isCopyInit() || Context == IC_ExplicitConvs;
738  }
739 
740  /// Determine whether this initialization has a source range containing the
741  /// locations of open and closing parentheses or braces.
742  bool hasParenOrBraceRange() const {
743  return Kind == IK_Direct || Kind == IK_Value || Kind == IK_DirectList;
744  }
745 
746  /// Retrieve the source range containing the locations of the open
747  /// and closing parentheses or braces for value, direct, and direct list
748  /// initializations.
750  assert(hasParenOrBraceRange() && "Only direct, value, and direct-list "
751  "initialization have parentheses or "
752  "braces");
753  return SourceRange(Locations[1], Locations[2]);
754  }
755 };
756 
757 /// Describes the sequence of initializations required to initialize
758 /// a given object or reference with a set of arguments.
760 public:
761  /// Describes the kind of initialization sequence computed.
763  /// A failed initialization sequence. The failure kind tells what
764  /// happened.
765  FailedSequence = 0,
766 
767  /// A dependent initialization, which could not be
768  /// type-checked due to the presence of dependent types or
769  /// dependently-typed expressions.
771 
772  /// A normal sequence.
773  NormalSequence
774  };
775 
776  /// Describes the kind of a particular step in an initialization
777  /// sequence.
778  enum StepKind {
779  /// Resolve the address of an overloaded function to a specific
780  /// function declaration.
782 
783  /// Perform a derived-to-base cast, producing an rvalue.
785 
786  /// Perform a derived-to-base cast, producing an xvalue.
788 
789  /// Perform a derived-to-base cast, producing an lvalue.
791 
792  /// Reference binding to an lvalue.
794 
795  /// Reference binding to a temporary.
797 
798  /// An optional copy of a temporary object to another
799  /// temporary object, which is permitted (but not required) by
800  /// C++98/03 but not C++0x.
802 
803  /// Direct-initialization from a reference-related object in the
804  /// final stage of class copy-initialization.
806 
807  /// Perform a user-defined conversion, either via a conversion
808  /// function or via a constructor.
810 
811  /// Perform a qualification conversion, producing an rvalue.
813 
814  /// Perform a qualification conversion, producing an xvalue.
816 
817  /// Perform a qualification conversion, producing an lvalue.
819 
820  /// Perform a conversion adding _Atomic to a type.
822 
823  /// Perform a load from a glvalue, producing an rvalue.
825 
826  /// Perform an implicit conversion sequence.
828 
829  /// Perform an implicit conversion sequence without narrowing.
831 
832  /// Perform list-initialization without a constructor.
834 
835  /// Unwrap the single-element initializer list for a reference.
837 
838  /// Rewrap the single-element initializer list for a reference.
840 
841  /// Perform initialization via a constructor.
843 
844  /// Perform initialization via a constructor, taking arguments from
845  /// a single InitListExpr.
847 
848  /// Zero-initialize the object
850 
851  /// C assignment
853 
854  /// Initialization by string
856 
857  /// An initialization that "converts" an Objective-C object
858  /// (not a point to an object) to another Objective-C object type.
860 
861  /// Array indexing for initialization by elementwise copy.
863 
864  /// Array initialization by elementwise copy.
866 
867  /// Array initialization (from an array rvalue).
869 
870  /// Array initialization (from an array rvalue) as a GNU extension.
872 
873  /// Array initialization from a parenthesized initializer list.
874  /// This is a GNU C++ extension.
876 
877  /// Pass an object by indirect copy-and-restore.
879 
880  /// Pass an object by indirect restore.
882 
883  /// Produce an Objective-C object pointer.
885 
886  /// Construct a std::initializer_list from an initializer list.
888 
889  /// Perform initialization via a constructor taking a single
890  /// std::initializer_list argument.
892 
893  /// Initialize an OpenCL sampler from an integer.
895 
896  /// Initialize an opaque OpenCL type (event_t, queue_t, etc.) with zero
897  SK_OCLZeroOpaqueType
898  };
899 
900  /// A single step in the initialization sequence.
901  class Step {
902  public:
903  /// The kind of conversion or initialization step we are taking.
905 
906  // The type that results from this initialization.
908 
909  struct F {
913  };
914 
915  union {
916  /// When Kind == SK_ResolvedOverloadedFunction or Kind ==
917  /// SK_UserConversion, the function that the expression should be
918  /// resolved to or the conversion function to call, respectively.
919  /// When Kind == SK_ConstructorInitialization or SK_ListConstruction,
920  /// the constructor to be called.
921  ///
922  /// Always a FunctionDecl, plus a Boolean flag telling if it was
923  /// selected from an overloaded set having size greater than 1.
924  /// For conversion decls, the naming class is the source type.
925  /// For construct decls, the naming class is the target type.
926  struct F Function;
927 
928  /// When Kind = SK_ConversionSequence, the implicit conversion
929  /// sequence.
931 
932  /// When Kind = SK_RewrapInitList, the syntactic form of the
933  /// wrapping list.
935  };
936 
937  void Destroy();
938  };
939 
940 private:
941  /// The kind of initialization sequence computed.
943 
944  /// Steps taken by this initialization.
945  SmallVector<Step, 4> Steps;
946 
947 public:
948  /// Describes why initialization failed.
949  enum FailureKind {
950  /// Too many initializers provided for a reference.
952 
953  /// Reference initialized from a parenthesized initializer list.
955 
956  /// Array must be initialized with an initializer list.
958 
959  /// Array must be initialized with an initializer list or a
960  /// string literal.
962 
963  /// Array must be initialized with an initializer list or a
964  /// wide string literal.
966 
967  /// Initializing a wide char array with narrow string literal.
969 
970  /// Initializing char array with wide string literal.
972 
973  /// Initializing wide char array with incompatible wide string
974  /// literal.
976 
977  /// Initializing char8_t array with plain string literal.
979 
980  /// Initializing char array with UTF-8 string literal.
982 
983  /// Array type mismatch.
985 
986  /// Non-constant array initializer
988 
989  /// Cannot resolve the address of an overloaded function.
991 
992  /// Overloading due to reference initialization failed.
994 
995  /// Non-const lvalue reference binding to a temporary.
997 
998  /// Non-const lvalue reference binding to a bit-field.
1000 
1001  /// Non-const lvalue reference binding to a vector element.
1003 
1004  /// Non-const lvalue reference binding to an lvalue of unrelated
1005  /// type.
1007 
1008  /// Rvalue reference binding to an lvalue.
1010 
1011  /// Reference binding drops qualifiers.
1013 
1014  /// Reference binding failed.
1016 
1017  /// Implicit conversion failed.
1019 
1020  /// Implicit conversion failed.
1022 
1023  /// Too many initializers for scalar
1025 
1026  /// Scalar initialized from a parenthesized initializer list.
1028 
1029  /// Reference initialization from an initializer list
1031 
1032  /// Initialization of some unused destination type with an
1033  /// initializer list.
1035 
1036  /// Overloading for a user-defined conversion failed.
1038 
1039  /// Overloading for initialization by constructor failed.
1041 
1042  /// Overloading for list-initialization by constructor failed.
1044 
1045  /// Default-initialization of a 'const' object.
1047 
1048  /// Initialization of an incomplete type.
1050 
1051  /// Variable-length array must not have an initializer.
1053 
1054  /// List initialization failed at some point.
1056 
1057  /// Initializer has a placeholder type which cannot be
1058  /// resolved by initialization.
1060 
1061  /// Trying to take the address of a function that doesn't support
1062  /// having its address taken.
1064 
1065  /// List-copy-initialization chose an explicit constructor.
1067  };
1068 
1069 private:
1070  /// The reason why initialization failed.
1071  FailureKind Failure;
1072 
1073  /// The failed result of overload resolution.
1074  OverloadingResult FailedOverloadResult;
1075 
1076  /// The candidate set created when initialization failed.
1077  OverloadCandidateSet FailedCandidateSet;
1078 
1079  /// The incomplete type that caused a failure.
1080  QualType FailedIncompleteType;
1081 
1082  /// The fixit that needs to be applied to make this initialization
1083  /// succeed.
1084  std::string ZeroInitializationFixit;
1085  SourceLocation ZeroInitializationFixitLoc;
1086 
1087 public:
1088  /// Call for initializations are invalid but that would be valid
1089  /// zero initialzations if Fixit was applied.
1090  void SetZeroInitializationFixit(const std::string& Fixit, SourceLocation L) {
1091  ZeroInitializationFixit = Fixit;
1092  ZeroInitializationFixitLoc = L;
1093  }
1094 
1095 private:
1096  /// Prints a follow-up note that highlights the location of
1097  /// the initialized entity, if it's remote.
1098  void PrintInitLocationNote(Sema &S, const InitializedEntity &Entity);
1099 
1100 public:
1101  /// Try to perform initialization of the given entity, creating a
1102  /// record of the steps required to perform the initialization.
1103  ///
1104  /// The generated initialization sequence will either contain enough
1105  /// information to diagnose
1106  ///
1107  /// \param S the semantic analysis object.
1108  ///
1109  /// \param Entity the entity being initialized.
1110  ///
1111  /// \param Kind the kind of initialization being performed.
1112  ///
1113  /// \param Args the argument(s) provided for initialization.
1114  ///
1115  /// \param TopLevelOfInitList true if we are initializing from an expression
1116  /// at the top level inside an initializer list. This disallows
1117  /// narrowing conversions in C++11 onwards.
1118  /// \param TreatUnavailableAsInvalid true if we want to treat unavailable
1119  /// as invalid.
1121  const InitializedEntity &Entity,
1122  const InitializationKind &Kind,
1123  MultiExprArg Args,
1124  bool TopLevelOfInitList = false,
1125  bool TreatUnavailableAsInvalid = true);
1126  void InitializeFrom(Sema &S, const InitializedEntity &Entity,
1127  const InitializationKind &Kind, MultiExprArg Args,
1128  bool TopLevelOfInitList, bool TreatUnavailableAsInvalid);
1129 
1131 
1132  /// Perform the actual initialization of the given entity based on
1133  /// the computed initialization sequence.
1134  ///
1135  /// \param S the semantic analysis object.
1136  ///
1137  /// \param Entity the entity being initialized.
1138  ///
1139  /// \param Kind the kind of initialization being performed.
1140  ///
1141  /// \param Args the argument(s) provided for initialization, ownership of
1142  /// which is transferred into the routine.
1143  ///
1144  /// \param ResultType if non-NULL, will be set to the type of the
1145  /// initialized object, which is the type of the declaration in most
1146  /// cases. However, when the initialized object is a variable of
1147  /// incomplete array type and the initializer is an initializer
1148  /// list, this type will be set to the completed array type.
1149  ///
1150  /// \returns an expression that performs the actual object initialization, if
1151  /// the initialization is well-formed. Otherwise, emits diagnostics
1152  /// and returns an invalid expression.
1153  ExprResult Perform(Sema &S,
1154  const InitializedEntity &Entity,
1155  const InitializationKind &Kind,
1156  MultiExprArg Args,
1157  QualType *ResultType = nullptr);
1158 
1159  /// Diagnose an potentially-invalid initialization sequence.
1160  ///
1161  /// \returns true if the initialization sequence was ill-formed,
1162  /// false otherwise.
1163  bool Diagnose(Sema &S,
1164  const InitializedEntity &Entity,
1165  const InitializationKind &Kind,
1166  ArrayRef<Expr *> Args);
1167 
1168  /// Determine the kind of initialization sequence computed.
1169  enum SequenceKind getKind() const { return SequenceKind; }
1170 
1171  /// Set the kind of sequence computed.
1172  void setSequenceKind(enum SequenceKind SK) { SequenceKind = SK; }
1173 
1174  /// Determine whether the initialization sequence is valid.
1175  explicit operator bool() const { return !Failed(); }
1176 
1177  /// Determine whether the initialization sequence is invalid.
1178  bool Failed() const { return SequenceKind == FailedSequence; }
1179 
1181 
1182  step_iterator step_begin() const { return Steps.begin(); }
1183  step_iterator step_end() const { return Steps.end(); }
1184 
1185  using step_range = llvm::iterator_range<step_iterator>;
1186 
1187  step_range steps() const { return {step_begin(), step_end()}; }
1188 
1189  /// Determine whether this initialization is a direct reference
1190  /// binding (C++ [dcl.init.ref]).
1191  bool isDirectReferenceBinding() const;
1192 
1193  /// Determine whether this initialization failed due to an ambiguity.
1194  bool isAmbiguous() const;
1195 
1196  /// Determine whether this initialization is direct call to a
1197  /// constructor.
1198  bool isConstructorInitialization() const;
1199 
1200  /// Returns whether the last step in this initialization sequence is a
1201  /// narrowing conversion, defined by C++0x [dcl.init.list]p7.
1202  ///
1203  /// If this function returns true, *isInitializerConstant will be set to
1204  /// describe whether *Initializer was a constant expression. If
1205  /// *isInitializerConstant is set to true, *ConstantValue will be set to the
1206  /// evaluated value of *Initializer.
1207  bool endsWithNarrowing(ASTContext &Ctx, const Expr *Initializer,
1208  bool *isInitializerConstant,
1209  APValue *ConstantValue) const;
1210 
1211  /// Add a new step in the initialization that resolves the address
1212  /// of an overloaded function to a specific function declaration.
1213  ///
1214  /// \param Function the function to which the overloaded function reference
1215  /// resolves.
1216  void AddAddressOverloadResolutionStep(FunctionDecl *Function,
1217  DeclAccessPair Found,
1218  bool HadMultipleCandidates);
1219 
1220  /// Add a new step in the initialization that performs a derived-to-
1221  /// base cast.
1222  ///
1223  /// \param BaseType the base type to which we will be casting.
1224  ///
1225  /// \param Category Indicates whether the result will be treated as an
1226  /// rvalue, an xvalue, or an lvalue.
1227  void AddDerivedToBaseCastStep(QualType BaseType,
1229 
1230  /// Add a new step binding a reference to an object.
1231  ///
1232  /// \param BindingTemporary True if we are binding a reference to a temporary
1233  /// object (thereby extending its lifetime); false if we are binding to an
1234  /// lvalue or an lvalue treated as an rvalue.
1235  void AddReferenceBindingStep(QualType T, bool BindingTemporary);
1236 
1237  /// Add a new step that makes an extraneous copy of the input
1238  /// to a temporary of the same class type.
1239  ///
1240  /// This extraneous copy only occurs during reference binding in
1241  /// C++98/03, where we are permitted (but not required) to introduce
1242  /// an extra copy. At a bare minimum, we must check that we could
1243  /// call the copy constructor, and produce a diagnostic if the copy
1244  /// constructor is inaccessible or no copy constructor matches.
1245  //
1246  /// \param T The type of the temporary being created.
1247  void AddExtraneousCopyToTemporary(QualType T);
1248 
1249  /// Add a new step that makes a copy of the input to an object of
1250  /// the given type, as the final step in class copy-initialization.
1251  void AddFinalCopy(QualType T);
1252 
1253  /// Add a new step invoking a conversion function, which is either
1254  /// a constructor or a conversion function.
1255  void AddUserConversionStep(FunctionDecl *Function,
1256  DeclAccessPair FoundDecl,
1257  QualType T,
1258  bool HadMultipleCandidates);
1259 
1260  /// Add a new step that performs a qualification conversion to the
1261  /// given type.
1262  void AddQualificationConversionStep(QualType Ty,
1263  ExprValueKind Category);
1264 
1265  /// Add a new step that performs conversion from non-atomic to atomic
1266  /// type.
1267  void AddAtomicConversionStep(QualType Ty);
1268 
1269  /// Add a new step that performs a load of the given type.
1270  ///
1271  /// Although the term "LValueToRValue" is conventional, this applies to both
1272  /// lvalues and xvalues.
1273  void AddLValueToRValueStep(QualType Ty);
1274 
1275  /// Add a new step that applies an implicit conversion sequence.
1276  void AddConversionSequenceStep(const ImplicitConversionSequence &ICS,
1277  QualType T, bool TopLevelOfInitList = false);
1278 
1279  /// Add a list-initialization step.
1280  void AddListInitializationStep(QualType T);
1281 
1282  /// Add a constructor-initialization step.
1283  ///
1284  /// \param FromInitList The constructor call is syntactically an initializer
1285  /// list.
1286  /// \param AsInitList The constructor is called as an init list constructor.
1287  void AddConstructorInitializationStep(DeclAccessPair FoundDecl,
1288  CXXConstructorDecl *Constructor,
1289  QualType T,
1290  bool HadMultipleCandidates,
1291  bool FromInitList, bool AsInitList);
1292 
1293  /// Add a zero-initialization step.
1294  void AddZeroInitializationStep(QualType T);
1295 
1296  /// Add a C assignment step.
1297  //
1298  // FIXME: It isn't clear whether this should ever be needed;
1299  // ideally, we would handle everything needed in C in the common
1300  // path. However, that isn't the case yet.
1301  void AddCAssignmentStep(QualType T);
1302 
1303  /// Add a string init step.
1304  void AddStringInitStep(QualType T);
1305 
1306  /// Add an Objective-C object conversion step, which is
1307  /// always a no-op.
1308  void AddObjCObjectConversionStep(QualType T);
1309 
1310  /// Add an array initialization loop step.
1311  void AddArrayInitLoopStep(QualType T, QualType EltTy);
1312 
1313  /// Add an array initialization step.
1314  void AddArrayInitStep(QualType T, bool IsGNUExtension);
1315 
1316  /// Add a parenthesized array initialization step.
1317  void AddParenthesizedArrayInitStep(QualType T);
1318 
1319  /// Add a step to pass an object by indirect copy-restore.
1320  void AddPassByIndirectCopyRestoreStep(QualType T, bool shouldCopy);
1321 
1322  /// Add a step to "produce" an Objective-C object (by
1323  /// retaining it).
1324  void AddProduceObjCObjectStep(QualType T);
1325 
1326  /// Add a step to construct a std::initializer_list object from an
1327  /// initializer list.
1328  void AddStdInitializerListConstructionStep(QualType T);
1329 
1330  /// Add a step to initialize an OpenCL sampler from an integer
1331  /// constant.
1332  void AddOCLSamplerInitStep(QualType T);
1333 
1334  /// Add a step to initialzie an OpenCL opaque type (event_t, queue_t, etc.)
1335  /// from a zero constant.
1336  void AddOCLZeroOpaqueTypeStep(QualType T);
1337 
1338  /// Add a step to initialize by zero types defined in the
1339  /// cl_intel_device_side_avc_motion_estimation OpenCL extension
1340  void AddOCLIntelSubgroupAVCZeroInitStep(QualType T);
1341 
1342  /// Add steps to unwrap a initializer list for a reference around a
1343  /// single element and rewrap it at the end.
1344  void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic);
1345 
1346  /// Note that this initialization sequence failed.
1347  void SetFailed(FailureKind Failure) {
1348  SequenceKind = FailedSequence;
1349  this->Failure = Failure;
1350  assert((Failure != FK_Incomplete || !FailedIncompleteType.isNull()) &&
1351  "Incomplete type failure requires a type!");
1352  }
1353 
1354  /// Note that this initialization sequence failed due to failed
1355  /// overload resolution.
1356  void SetOverloadFailure(FailureKind Failure, OverloadingResult Result);
1357 
1358  /// Retrieve a reference to the candidate set when overload
1359  /// resolution fails.
1361  return FailedCandidateSet;
1362  }
1363 
1364  /// Get the overloading result, for when the initialization
1365  /// sequence failed due to a bad overload.
1367  return FailedOverloadResult;
1368  }
1369 
1370  /// Note that this initialization sequence failed due to an
1371  /// incomplete type.
1372  void setIncompleteTypeFailure(QualType IncompleteType) {
1373  FailedIncompleteType = IncompleteType;
1374  SetFailed(FK_Incomplete);
1375  }
1376 
1377  /// Determine why initialization failed.
1379  assert(Failed() && "Not an initialization failure!");
1380  return Failure;
1381  }
1382 
1383  /// Dump a representation of this initialization sequence to
1384  /// the given stream, for debugging purposes.
1385  void dump(raw_ostream &OS) const;
1386 
1387  /// Dump a representation of this initialization sequence to
1388  /// standard error, for debugging purposes.
1389  void dump() const;
1390 };
1391 
1392 } // namespace clang
1393 
1394 #endif // LLVM_CLANG_SEMA_INITIALIZATION_H
Perform a derived-to-base cast, producing an lvalue.
Defines the clang::ASTContext interface.
QualType getVariableArrayDecayedType(QualType Ty) const
Returns a vla type where known sizes are replaced with [*].
Represents a function declaration or definition.
Definition: Decl.h:1732
InitListExpr * WrappingSyntacticList
When Kind = SK_RewrapInitList, the syntactic form of the wrapping list.
step_iterator step_begin() const
static InitializationKind CreateDirectList(SourceLocation InitLoc, SourceLocation LBraceLoc, SourceLocation RBraceLoc)
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
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:642
unsigned Index
When Kind == EK_ArrayElement, EK_VectorElement, or EK_ComplexElement, the index of the array or vecto...
DeclarationName getName() const
Retrieve the name of the entity being initialized.
Definition: SemaInit.cpp:3081
Produce an Objective-C object pointer.
Initializing char array with wide string literal.
static InitializedEntity InitializeException(SourceLocation ThrowLoc, QualType Type, bool NRVO)
Create the initialization entity for an exception object.
Perform an implicit conversion sequence without narrowing.
An initialization that "converts" an Objective-C object (not a point to an object) to another Objecti...
Perform a qualification conversion, producing an rvalue.
C Language Family Type Representation.
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
uintptr_t Base
When Kind == EK_Base, the base specifier that provides the base class.
FailureKind getFailureKind() const
Determine why initialization failed.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
The base class of the type hierarchy.
Definition: Type.h:1415
The entity being initialized is a variable.
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
Overloading for a user-defined conversion failed.
TypeSourceInfo * getTypeSourceInfo() const
Retrieve complete type-source information for the object being constructed, if known.
A container of type source information.
Definition: Decl.h:86
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:39
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 InitializedEntity InitializeMemberFromDefaultMemberInitializer(FieldDecl *Member)
Create the initialization entity for a default member initializer.
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2478
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...
Initialize an OpenCL sampler from an integer.
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a base class subobject.
Definition: SemaInit.cpp:3066
Represents a variable declaration or definition.
Definition: Decl.h:812
Array initialization by elementwise copy.
SourceLocation getEqualLoc() const
Retrieve the location of the equal sign for copy initialization (if present).
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
Non-const lvalue reference binding to an lvalue of unrelated type.
SourceLocation getThrowLoc() const
Determine the location of the &#39;throw&#39; keyword when initializing an exception object.
static InitializedEntity InitializeResult(SourceLocation ReturnLoc, QualType Type, bool NRVO)
Create the initialization entity for the result of a function.
Perform a derived-to-base cast, producing an rvalue.
static InitializationKind CreateDirectList(SourceLocation InitLoc)
EntityKind getKind() const
Determine the kind of initialization.
Initializing char array with UTF-8 string literal.
void setElementIndex(unsigned Index)
If this is already the initializer for an array or vector element, sets the element index...
Represents a parameter to a function.
Definition: Decl.h:1551
The entity being initialized is a temporary object.
const CXXBaseSpecifier * getBaseSpecifier() const
Retrieve the base specifier.
Non-const lvalue reference binding to a vector element.
bool isImplicitMemberInitializer() const
Is this the implicit initialization of a member of a class from a defaulted constructor?
Construct a std::initializer_list from an initializer list.
Trying to take the address of a function that doesn&#39;t support having its address taken.
One of these records is kept for each identifier that is lexed.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
bool isInheritedVirtualBase() const
Return whether the base is an inherited virtual base.
ImplicitConversionSequence * ICS
When Kind = SK_ConversionSequence, the implicit conversion sequence.
static SourceLocation getFromRawEncoding(unsigned Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:280
Represents a member of a struct/union/class.
Definition: Decl.h:2575
Rewrap the single-element initializer list for a reference.
FieldDecl * getAnonField() const
Definition: Decl.h:2851
int Category
Definition: Format.cpp:1632
StringRef getCapturedVarName() const
For a lambda capture, return the capture&#39;s name.
static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc, QualType Type, bool NRVO)
Perform initialization via a constructor taking a single std::initializer_list argument.
Describes an C or C++ initializer list.
Definition: Expr.h:4091
static InitializedEntity InitializeTemporary(TypeSourceInfo *TypeInfo)
Create the initialization entity for a temporary.
SourceRange getParenOrBraceRange() const
Retrieve the source range containing the locations of the open and closing parentheses or braces for ...
EntityKind
Specifies the kind of entity being initialized.
static InitializedEntity InitializeDelegation(QualType Type)
Create the initialization entity for a delegated constructor.
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...
static InitializedEntity InitializeLambdaToBlock(SourceLocation BlockVarLoc, QualType Type, bool NRVO)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type...
Definition: Type.h:6765
OverloadCandidateSet & getFailedCandidateSet()
Retrieve a reference to the candidate set when overload resolution fails.
unsigned getElementIndex() const
If this is an array, vector, or complex number element, get the element&#39;s index.
Variable-length array must not have an initializer.
Initialization of an incomplete type.
The entity being initialized is a non-static data member subobject.
static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool isImplicit=false)
Create a value initialization.
Unwrap the single-element initializer list for a reference.
SmallVectorImpl< Step >::const_iterator step_iterator
The entity being initialized is an element of a vector.
Perform initialization via a constructor.
Perform a user-defined conversion, either via a conversion function or via a constructor.
The entity being initialized is a function parameter.
bool hasParenOrBraceRange() const
Determine whether this initialization has a source range containing the locations of open and closing...
ValueDecl * getDecl() const
Retrieve the variable, parameter, or field being initialized.
Definition: SemaInit.cpp:3117
static InitializedEntity InitializeNew(SourceLocation NewLoc, QualType Type)
Create the initialization entity for an object allocated via new.
NodeId Parent
Definition: ASTDiff.cpp:192
Perform an implicit conversion sequence.
bool hasAttr() const
Definition: DeclBase.h:531
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
Overloading for list-initialization by constructor failed.
Perform list-initialization without a constructor.
Non-const lvalue reference binding to a bit-field.
Cannot resolve the address of an overloaded function.
static InitializedEntity InitializeTemporary(TypeSourceInfo *TypeInfo, QualType Type)
Create the initialization entity for a temporary.
bool isFunctionalCast() const
Determine whether this is a functional-style cast.
unsigned allocateManglingNumber() const
The entity being initialized is a field of block descriptor for the copied-in c++ object...
static InitializedEntity InitializeMember(IndirectFieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
Initializing wide char array with incompatible wide string literal.
The entity being initialized is the real or imaginary part of a complex number.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
This represents one expression.
Definition: Expr.h:106
Defines the clang::LangOptions interface.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:107
Initializing char8_t array with plain string literal.
static InitializationKind CreateFunctionalCast(SourceRange TypeRange, bool InitList)
Create a direct initialization for a functional cast.
void dump() const
Dump a representation of the initialized entity to standard error, for debugging purposes.
Definition: SemaInit.cpp:3224
Scalar initialized from a parenthesized initializer list.
uintptr_t Parameter
When Kind == EK_Parameter, the ParmVarDecl, with the low bit indicating whether the parameter is "con...
The entity being initialized is an object (or array of objects) allocated via new.
Perform a qualification conversion, producing an xvalue.
OverloadingResult getFailedOverloadResult() const
Get the overloading result, for when the initialization sequence failed due to a bad overload...
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
Initializing a wide char array with narrow string literal.
#define bool
Definition: stdbool.h:31
Resolve the address of an overloaded function to a specific function declaration. ...
The entity being initialized is an exception object that is being thrown.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
bool isExplicitCast() const
Determine whether this initialization is an explicit cast.
Initializer has a placeholder type which cannot be resolved by initialization.
SourceLocation getEnd() const
SourceLocation getLocation() const
Retrieve the location at which initialization is occurring.
bool AllowExplicit() const
Retrieve whether this initialization allows the use of explicit constructors.
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 isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:707
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c.h:90
InitKind getKind() const
Determine the initialization kind.
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:293
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
FailureKind
Describes why initialization failed.
List initialization failed at some point.
Perform a conversion adding _Atomic to a type.
bool allowExplicitConversionFunctionsInRefBinding() const
Retrieve whether this initialization allows the use of explicit conversion functions when binding a r...
Perform a qualification conversion, producing an lvalue.
Kind
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Definition: Overload.h:487
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
bool allowsNRVO() const
Determine whether this initialization allows the named return value optimization, which also applies ...
Definition: SemaInit.cpp:3149
SequenceKind
Describes the kind of initialization sequence computed.
Array indexing for initialization by elementwise copy.
Encodes a location in the source.
Reference initialization from an initializer list.
static InitializedEntity InitializeLambdaCapture(IdentifierInfo *VarID, QualType FieldType, SourceLocation Loc)
Create the initialization entity for a lambda capture.
bool isCStyleOrFunctionalCast() const
Determine whether this initialization is a C-style cast.
StepKind
Describes the kind of a particular step in an initialization sequence.
llvm::iterator_range< step_iterator > step_range
TypeSourceInfo * TypeInfo
When Kind == EK_Temporary or EK_CompoundLiteralInit, the type source information for the temporary...
OverloadingResult
OverloadingResult - Capture the result of performing overload resolution.
Definition: Overload.h:52
VD Variable
When Kind == EK_Variable, EK_Member or EK_Binding, the variable.
static InitializedEntity InitializeElement(ASTContext &Context, unsigned Index, const InitializedEntity &Parent)
Create the initialization entity for an array element.
Initialization of some unused destination type with an initializer list.
static InitializedEntity InitializeCompoundLiteralInit(TypeSourceInfo *TSI)
Create the entity for a compound literal initializer.
The entity being initialized is the result of a function call.
The entity being implicitly initialized back to the formal result type.
The entity being initialized is the initializer for a compound literal.
Describes the kind of initialization being performed, along with location information for tokens rela...
The entity being initialized is an element of an array.
Reference initialized from a parenthesized initializer list.
Overloading for initialization by constructor failed.
An optional copy of a temporary object to another temporary object, which is permitted (but not requi...
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:830
static InitializationKind CreateCast(SourceRange TypeRange)
Create a direct initialization due to a cast that isn&#39;t a C-style or functional cast.
Pass an object by indirect copy-and-restore.
Defines various enumerations that describe declaration and type specifiers.
A POD class for pairing a NamedDecl* with an access specifier.
void SetFailed(FailureKind Failure)
Note that this initialization sequence failed.
Array must be initialized with an initializer list or a string literal.
Optional< types::ID > Type
QualType getType() const
Retrieve type being initialized.
Dataflow Directional Tag Classes.
void setIncompleteTypeFailure(QualType IncompleteType)
Note that this initialization sequence failed due to an incomplete type.
A single step in the initialization sequence.
static InitializedEntity InitializeParameter(ASTContext &Context, QualType Type, bool Consumed)
Create the initialization entity for a parameter that is only known by its type.
Array must be initialized with an initializer list or a wide string literal.
Too many initializers provided for a reference.
Perform a load from a glvalue, producing an rvalue.
Represents a field injected from an anonymous union/struct into the parent scope. ...
Definition: Decl.h:2821
const InitializedEntity * getParent() const
Retrieve the parent of the entity being initialized, when the initialization itself is occurring with...
The name of a declaration.
Array initialization (from an array rvalue) as a GNU extension.
static InitializationKind CreateCStyleCast(SourceLocation StartLoc, SourceRange TypeRange, bool InitList)
Create a direct initialization for a C-style cast.
Overloading due to reference initialization failed.
Array must be initialized with an initializer list.
The entity being initialized is a structured binding of a decomposition declaration.
step_iterator step_end() const
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
Represents a base class of a C++ class.
Definition: DeclCXX.h:192
static InitializedEntity InitializeStmtExprResult(SourceLocation ReturnLoc, QualType Type)
Direct-initialization from a reference-related object in the final stage of class copy-initialization...
bool Failed() const
Determine whether the initialization sequence is invalid.
Defines the clang::SourceLocation class and associated facilities.
Describes the sequence of initializations required to initialize a given object or reference with a s...
static InitializedEntity InitializeRelatedResult(ObjCMethodDecl *MD, QualType Type)
Create the initialization entity for a related result.
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6138
Perform initialization via a constructor, taking arguments from a single InitListExpr.
SourceRange getRange() const
Retrieve the source range that covers the initialization.
bool isParameterConsumed() const
Determine whether this initialization consumes the parameter.
The entity being initialized is a field of block descriptor for the copied-in lambda object that&#39;s us...
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.
A dependent initialization, which could not be type-checked due to the presence of dependent types or...
bool isCStyleCast() const
Determine whether this is a C-style cast.
ObjCMethodDecl * MethodDecl
When Kind == EK_RelatedResult, the ObjectiveC method where result type was implicitly changed to acco...
The initialization is being done by a delegating constructor.
Array initialization (from an array rvalue).
InitKind
The kind of initialization being performed.
QualType getType() const
Definition: Decl.h:647
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm, QualType Type)
Create the initialization entity for a parameter, but use another type.
Default-initialization of a &#39;const&#39; object.
A trivial tuple used to represent a source range.
Describes an entity that is being initialized.
bool isDefaultMemberInitializer() const
Is this the default member initializer of a member (specified inside the class definition)?
ObjCMethodDecl * getMethodDecl() const
Retrieve the ObjectiveC method being initialized.
SourceLocation getBegin() const
const LangOptions & getLangOpts() const
Definition: ASTContext.h:716
bool isVariableLengthArrayNew() const
Determine whether this is an array new with an unknown bound.
Direct list-initialization.
Array initialization from a parenthesized initializer list.
static InitializedEntity InitializeBinding(VarDecl *Binding)
Create the initialization entity for a structured binding.
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97