clang  3.9.0
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 #ifndef LLVM_CLANG_SEMA_INITIALIZATION_H
14 #define LLVM_CLANG_SEMA_INITIALIZATION_H
15 
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/Attr.h"
18 #include "clang/AST/Type.h"
21 #include "clang/Sema/Overload.h"
22 #include "clang/Sema/Ownership.h"
23 #include "llvm/ADT/PointerIntPair.h"
24 #include "llvm/ADT/SmallVector.h"
25 #include <cassert>
26 
27 namespace clang {
28 
29 class CXXBaseSpecifier;
30 class DeclaratorDecl;
31 class DeclaratorInfo;
32 class FieldDecl;
33 class FunctionDecl;
34 class ParmVarDecl;
35 class Sema;
36 class TypeLoc;
37 class VarDecl;
38 class ObjCMethodDecl;
39 
40 /// \brief Describes an entity that is being initialized.
42 public:
43  /// \brief Specifies the kind of entity being initialized.
44  enum EntityKind {
45  /// \brief The entity being initialized is a variable.
47  /// \brief The entity being initialized is a function parameter.
49  /// \brief The entity being initialized is the result of a function call.
51  /// \brief The entity being initialized is an exception object that
52  /// is being thrown.
54  /// \brief The entity being initialized is a non-static data member
55  /// subobject.
57  /// \brief The entity being initialized is an element of an array.
59  /// \brief The entity being initialized is an object (or array of
60  /// objects) allocated via new.
62  /// \brief The entity being initialized is a temporary object.
64  /// \brief The entity being initialized is a base member subobject.
66  /// \brief The initialization is being done by a delegating constructor.
68  /// \brief The entity being initialized is an element of a vector.
69  /// or vector.
71  /// \brief The entity being initialized is a field of block descriptor for
72  /// the copied-in c++ object.
74  /// \brief The entity being initialized is the real or imaginary part of a
75  /// complex number.
77  /// \brief The entity being initialized is the field that captures a
78  /// variable in a lambda.
80  /// \brief The entity being initialized is the initializer for a compound
81  /// literal.
83  /// \brief The entity being implicitly initialized back to the formal
84  /// result type.
86  /// \brief The entity being initialized is a function parameter; function
87  /// is member of group of audited CF APIs.
89 
90  // Note: err_init_conversion_failed in DiagnosticSemaKinds.td uses this
91  // enum as an index for its first %select. When modifying this list,
92  // that diagnostic text needs to be updated as well.
93  };
94 
95 private:
96  /// \brief The kind of entity being initialized.
98 
99  /// \brief If non-NULL, the parent entity in which this
100  /// initialization occurs.
101  const InitializedEntity *Parent;
102 
103  /// \brief The type of the object or reference being initialized.
104  QualType Type;
105 
106  /// \brief The mangling number for the next reference temporary to be created.
107  mutable unsigned ManglingNumber;
108 
109  struct LN {
110  /// \brief When Kind == EK_Result, EK_Exception, EK_New, the
111  /// location of the 'return', 'throw', or 'new' keyword,
112  /// respectively. When Kind == EK_Temporary, the location where
113  /// the temporary is being created.
114  unsigned Location;
115 
116  /// \brief Whether the entity being initialized may end up using the
117  /// named return value optimization (NRVO).
118  bool NRVO;
119  };
120 
121  struct C {
122  /// \brief The name of the variable being captured by an EK_LambdaCapture.
123  IdentifierInfo *VarID;
124 
125  /// \brief The source location at which the capture occurs.
126  unsigned Location;
127  };
128 
129  union {
130  /// \brief When Kind == EK_Variable, or EK_Member, the VarDecl or
131  /// FieldDecl, respectively.
133 
134  /// \brief When Kind == EK_RelatedResult, the ObjectiveC method where
135  /// result type was implicitly changed to accommodate ARC semantics.
137 
138  /// \brief When Kind == EK_Parameter, the ParmVarDecl, with the
139  /// low bit indicating whether the parameter is "consumed".
141 
142  /// \brief When Kind == EK_Temporary or EK_CompoundLiteralInit, the type
143  /// source information for the temporary.
145 
146  struct LN LocAndNRVO;
147 
148  /// \brief When Kind == EK_Base, the base specifier that provides the
149  /// base class. The lower bit specifies whether the base is an inherited
150  /// virtual base.
152 
153  /// \brief When Kind == EK_ArrayElement, EK_VectorElement, or
154  /// EK_ComplexElement, the index of the array or vector element being
155  /// initialized.
156  unsigned Index;
157 
158  struct C Capture;
159  };
160 
161  InitializedEntity() : ManglingNumber(0) {}
162 
163  /// \brief Create the initialization entity for a variable.
164  InitializedEntity(VarDecl *Var)
165  : Kind(EK_Variable), Parent(nullptr), Type(Var->getType()),
166  ManglingNumber(0), VariableOrMember(Var) { }
167 
168  /// \brief Create the initialization entity for the result of a
169  /// function, throwing an object, performing an explicit cast, or
170  /// initializing a parameter for which there is no declaration.
171  InitializedEntity(EntityKind Kind, SourceLocation Loc, QualType Type,
172  bool NRVO = false)
173  : Kind(Kind), Parent(nullptr), Type(Type), ManglingNumber(0)
174  {
175  LocAndNRVO.Location = Loc.getRawEncoding();
176  LocAndNRVO.NRVO = NRVO;
177  }
178 
179  /// \brief Create the initialization entity for a member subobject.
180  InitializedEntity(FieldDecl *Member, const InitializedEntity *Parent)
181  : Kind(EK_Member), Parent(Parent), Type(Member->getType()),
182  ManglingNumber(0), VariableOrMember(Member) { }
183 
184  /// \brief Create the initialization entity for an array element.
185  InitializedEntity(ASTContext &Context, unsigned Index,
186  const InitializedEntity &Parent);
187 
188  /// \brief Create the initialization entity for a lambda capture.
189  InitializedEntity(IdentifierInfo *VarID, QualType FieldType, SourceLocation Loc)
190  : Kind(EK_LambdaCapture), Parent(nullptr), Type(FieldType),
191  ManglingNumber(0)
192  {
193  Capture.VarID = VarID;
194  Capture.Location = Loc.getRawEncoding();
195  }
196 
197 public:
198  /// \brief Create the initialization entity for a variable.
200  return InitializedEntity(Var);
201  }
202 
203  /// \brief Create the initialization entity for a parameter.
205  ParmVarDecl *Parm) {
206  return InitializeParameter(Context, Parm, Parm->getType());
207  }
208 
209  /// \brief Create the initialization entity for a parameter, but use
210  /// another type.
212  ParmVarDecl *Parm,
213  QualType Type) {
214  bool Consumed = (Context.getLangOpts().ObjCAutoRefCount &&
215  Parm->hasAttr<NSConsumedAttr>());
216 
217  InitializedEntity Entity;
218  Entity.Kind = EK_Parameter;
219  Entity.Type =
221  Entity.Parent = nullptr;
222  Entity.Parameter
223  = (static_cast<uintptr_t>(Consumed) | reinterpret_cast<uintptr_t>(Parm));
224  return Entity;
225  }
226 
227  /// \brief Create the initialization entity for a parameter that is
228  /// only known by its type.
230  QualType Type,
231  bool Consumed) {
232  InitializedEntity Entity;
233  Entity.Kind = EK_Parameter;
234  Entity.Type = Context.getVariableArrayDecayedType(Type);
235  Entity.Parent = nullptr;
236  Entity.Parameter = (Consumed);
237  return Entity;
238  }
239 
240  /// \brief Create the initialization entity for the result of a function.
242  QualType Type, bool NRVO) {
243  return InitializedEntity(EK_Result, ReturnLoc, Type, NRVO);
244  }
245 
247  QualType Type, bool NRVO) {
248  return InitializedEntity(EK_BlockElement, BlockVarLoc, Type, NRVO);
249  }
250 
251  /// \brief Create the initialization entity for an exception object.
253  QualType Type, bool NRVO) {
254  return InitializedEntity(EK_Exception, ThrowLoc, Type, NRVO);
255  }
256 
257  /// \brief Create the initialization entity for an object allocated via new.
259  return InitializedEntity(EK_New, NewLoc, Type);
260  }
261 
262  /// \brief Create the initialization entity for a temporary.
265  Result.TypeInfo = nullptr;
266  return Result;
267  }
268 
269  /// \brief Create the initialization entity for a temporary.
272  TypeInfo->getType());
273  Result.TypeInfo = TypeInfo;
274  return Result;
275  }
276 
277  /// \brief Create the initialization entity for a related result.
279  QualType Type) {
281  Result.MethodDecl = MD;
282  return Result;
283  }
284 
285 
286  /// \brief Create the initialization entity for a base class subobject.
287  static InitializedEntity
289  bool IsInheritedVirtualBase,
290  const InitializedEntity *Parent = nullptr);
291 
292  /// \brief Create the initialization entity for a delegated constructor.
295  }
296 
297  /// \brief Create the initialization entity for a member subobject.
298  static InitializedEntity
300  const InitializedEntity *Parent = nullptr) {
301  return InitializedEntity(Member, Parent);
302  }
303 
304  /// \brief Create the initialization entity for a member subobject.
305  static InitializedEntity
307  const InitializedEntity *Parent = nullptr) {
308  return InitializedEntity(Member->getAnonField(), Parent);
309  }
310 
311  /// \brief Create the initialization entity for an array element.
313  unsigned Index,
314  const InitializedEntity &Parent) {
315  return InitializedEntity(Context, Index, Parent);
316  }
317 
318  /// \brief Create the initialization entity for a lambda capture.
320  QualType FieldType,
321  SourceLocation Loc) {
322  return InitializedEntity(VarID, FieldType, Loc);
323  }
324 
325  /// \brief Create the entity for a compound literal initializer.
328  TSI->getType());
329  Result.TypeInfo = TSI;
330  return Result;
331  }
332 
333 
334  /// \brief Determine the kind of initialization.
335  EntityKind getKind() const { return Kind; }
336 
337  /// \brief Retrieve the parent of the entity being initialized, when
338  /// the initialization itself is occurring within the context of a
339  /// larger initialization.
340  const InitializedEntity *getParent() const { return Parent; }
341 
342  /// \brief Retrieve type being initialized.
343  QualType getType() const { return Type; }
344 
345  /// \brief Retrieve complete type-source information for the object being
346  /// constructed, if known.
348  if (Kind == EK_Temporary || Kind == EK_CompoundLiteralInit)
349  return TypeInfo;
350 
351  return nullptr;
352  }
353 
354  /// \brief Retrieve the name of the entity being initialized.
355  DeclarationName getName() const;
356 
357  /// \brief Retrieve the variable, parameter, or field being
358  /// initialized.
359  DeclaratorDecl *getDecl() const;
360 
361  /// \brief Retrieve the ObjectiveC method being initialized.
363 
364  /// \brief Determine whether this initialization allows the named return
365  /// value optimization, which also applies to thrown objects.
366  bool allowsNRVO() const;
367 
368  bool isParameterKind() const {
369  return (getKind() == EK_Parameter ||
371  }
372  /// \brief Determine whether this initialization consumes the
373  /// parameter.
374  bool isParameterConsumed() const {
375  assert(isParameterKind() && "Not a parameter");
376  return (Parameter & 1);
377  }
378 
379  /// \brief Retrieve the base specifier.
381  assert(getKind() == EK_Base && "Not a base specifier");
382  return reinterpret_cast<const CXXBaseSpecifier *>(Base & ~0x1);
383  }
384 
385  /// \brief Return whether the base is an inherited virtual base.
386  bool isInheritedVirtualBase() const {
387  assert(getKind() == EK_Base && "Not a base specifier");
388  return Base & 0x1;
389  }
390 
391  /// \brief Determine the location of the 'return' keyword when initializing
392  /// the result of a function call.
394  assert(getKind() == EK_Result && "No 'return' location!");
396  }
397 
398  /// \brief Determine the location of the 'throw' keyword when initializing
399  /// an exception object.
401  assert(getKind() == EK_Exception && "No 'throw' location!");
403  }
404 
405  /// \brief If this is an array, vector, or complex number element, get the
406  /// element's index.
407  unsigned getElementIndex() const {
408  assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement ||
410  return Index;
411  }
412  /// \brief If this is already the initializer for an array or vector
413  /// element, sets the element index.
414  void setElementIndex(unsigned Index) {
415  assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement ||
417  this->Index = Index;
418  }
419  /// \brief For a lambda capture, return the capture's name.
420  StringRef getCapturedVarName() const {
421  assert(getKind() == EK_LambdaCapture && "Not a lambda capture!");
422  return Capture.VarID->getName();
423  }
424  /// \brief Determine the location of the capture when initializing
425  /// field from a captured variable in a lambda.
427  assert(getKind() == EK_LambdaCapture && "Not a lambda capture!");
429  }
430 
433  }
434 
435  unsigned allocateManglingNumber() const { return ++ManglingNumber; }
436 
437  /// Dump a representation of the initialized entity to standard error,
438  /// for debugging purposes.
439  void dump() const;
440 
441 private:
442  unsigned dumpImpl(raw_ostream &OS) const;
443 };
444 
445 /// \brief Describes the kind of initialization being performed, along with
446 /// location information for tokens related to the initialization (equal sign,
447 /// parentheses).
449 public:
450  /// \brief The kind of initialization being performed.
451  enum InitKind {
452  IK_Direct, ///< Direct initialization
453  IK_DirectList, ///< Direct list-initialization
454  IK_Copy, ///< Copy initialization
455  IK_Default, ///< Default initialization
456  IK_Value ///< Value initialization
457  };
458 
459 private:
460  /// \brief The context of the initialization.
461  enum InitContext {
462  IC_Normal, ///< Normal context
463  IC_ExplicitConvs, ///< Normal context, but allows explicit conversion funcs
464  IC_Implicit, ///< Implicit context (value initialization)
465  IC_StaticCast, ///< Static cast context
466  IC_CStyleCast, ///< C-style cast context
467  IC_FunctionalCast ///< Functional cast context
468  };
469 
470  /// \brief The kind of initialization being performed.
471  InitKind Kind : 8;
472 
473  /// \brief The context of the initialization.
474  InitContext Context : 8;
475 
476  /// \brief The source locations involved in the initialization.
477  SourceLocation Locations[3];
478 
479  InitializationKind(InitKind Kind, InitContext Context, SourceLocation Loc1,
480  SourceLocation Loc2, SourceLocation Loc3)
481  : Kind(Kind), Context(Context)
482  {
483  Locations[0] = Loc1;
484  Locations[1] = Loc2;
485  Locations[2] = Loc3;
486  }
487 
488 public:
489  /// \brief Create a direct initialization.
491  SourceLocation LParenLoc,
492  SourceLocation RParenLoc) {
493  return InitializationKind(IK_Direct, IC_Normal,
494  InitLoc, LParenLoc, RParenLoc);
495  }
496 
498  return InitializationKind(IK_DirectList, IC_Normal,
499  InitLoc, InitLoc, InitLoc);
500  }
501 
502  /// \brief Create a direct initialization due to a cast that isn't a C-style
503  /// or functional cast.
505  return InitializationKind(IK_Direct, IC_StaticCast, TypeRange.getBegin(),
506  TypeRange.getBegin(), TypeRange.getEnd());
507  }
508 
509  /// \brief Create a direct initialization for a C-style cast.
511  SourceRange TypeRange,
512  bool InitList) {
513  // C++ cast syntax doesn't permit init lists, but C compound literals are
514  // exactly that.
515  return InitializationKind(InitList ? IK_DirectList : IK_Direct,
516  IC_CStyleCast, StartLoc, TypeRange.getBegin(),
517  TypeRange.getEnd());
518  }
519 
520  /// \brief Create a direct initialization for a functional cast.
522  bool InitList) {
523  return InitializationKind(InitList ? IK_DirectList : IK_Direct,
524  IC_FunctionalCast, TypeRange.getBegin(),
525  TypeRange.getBegin(), TypeRange.getEnd());
526  }
527 
528  /// \brief Create a copy initialization.
530  SourceLocation EqualLoc,
531  bool AllowExplicitConvs = false) {
532  return InitializationKind(IK_Copy,
533  AllowExplicitConvs? IC_ExplicitConvs : IC_Normal,
534  InitLoc, EqualLoc, EqualLoc);
535  }
536 
537  /// \brief Create a default initialization.
539  return InitializationKind(IK_Default, IC_Normal, InitLoc, InitLoc, InitLoc);
540  }
541 
542  /// \brief Create a value initialization.
544  SourceLocation LParenLoc,
545  SourceLocation RParenLoc,
546  bool isImplicit = false) {
547  return InitializationKind(IK_Value, isImplicit ? IC_Implicit : IC_Normal,
548  InitLoc, LParenLoc, RParenLoc);
549  }
550 
551  /// \brief Determine the initialization kind.
552  InitKind getKind() const {
553  return Kind;
554  }
555 
556  /// \brief Determine whether this initialization is an explicit cast.
557  bool isExplicitCast() const {
558  return Context >= IC_StaticCast;
559  }
560 
561  /// \brief Determine whether this initialization is a C-style cast.
562  bool isCStyleOrFunctionalCast() const {
563  return Context >= IC_CStyleCast;
564  }
565 
566  /// \brief Determine whether this is a C-style cast.
567  bool isCStyleCast() const {
568  return Context == IC_CStyleCast;
569  }
570 
571  /// \brief Determine whether this is a functional-style cast.
572  bool isFunctionalCast() const {
573  return Context == IC_FunctionalCast;
574  }
575 
576  /// \brief Determine whether this initialization is an implicit
577  /// value-initialization, e.g., as occurs during aggregate
578  /// initialization.
579  bool isImplicitValueInit() const { return Context == IC_Implicit; }
580 
581  /// \brief Retrieve the location at which initialization is occurring.
582  SourceLocation getLocation() const { return Locations[0]; }
583 
584  /// \brief Retrieve the source range that covers the initialization.
586  return SourceRange(Locations[0], Locations[2]);
587  }
588 
589  /// \brief Retrieve the location of the equal sign for copy initialization
590  /// (if present).
592  assert(Kind == IK_Copy && "Only copy initialization has an '='");
593  return Locations[1];
594  }
595 
596  bool isCopyInit() const { return Kind == IK_Copy; }
597 
598  /// \brief Retrieve whether this initialization allows the use of explicit
599  /// constructors.
600  bool AllowExplicit() const { return !isCopyInit(); }
601 
602  /// \brief Retrieve whether this initialization allows the use of explicit
603  /// conversion functions when binding a reference. If the reference is the
604  /// first parameter in a copy or move constructor, such conversions are
605  /// permitted even though we are performing copy-initialization.
607  return !isCopyInit() || Context == IC_ExplicitConvs;
608  }
609 
610  /// \brief Retrieve the source range containing the locations of the open
611  /// and closing parentheses for value and direct initializations.
613  assert((Kind == IK_Direct || Kind == IK_Value) &&
614  "Only direct- and value-initialization have parentheses");
615  return SourceRange(Locations[1], Locations[2]);
616  }
617 };
618 
619 /// \brief Describes the sequence of initializations required to initialize
620 /// a given object or reference with a set of arguments.
622 public:
623  /// \brief Describes the kind of initialization sequence computed.
625  /// \brief A failed initialization sequence. The failure kind tells what
626  /// happened.
628 
629  /// \brief A dependent initialization, which could not be
630  /// type-checked due to the presence of dependent types or
631  /// dependently-typed expressions.
633 
634  /// \brief A normal sequence.
636  };
637 
638  /// \brief Describes the kind of a particular step in an initialization
639  /// sequence.
640  enum StepKind {
641  /// \brief Resolve the address of an overloaded function to a specific
642  /// function declaration.
644  /// \brief Perform a derived-to-base cast, producing an rvalue.
646  /// \brief Perform a derived-to-base cast, producing an xvalue.
648  /// \brief Perform a derived-to-base cast, producing an lvalue.
650  /// \brief Reference binding to an lvalue.
652  /// \brief Reference binding to a temporary.
654  /// \brief An optional copy of a temporary object to another
655  /// temporary object, which is permitted (but not required) by
656  /// C++98/03 but not C++0x.
658  /// \brief Perform a user-defined conversion, either via a conversion
659  /// function or via a constructor.
661  /// \brief Perform a qualification conversion, producing an rvalue.
663  /// \brief Perform a qualification conversion, producing an xvalue.
665  /// \brief Perform a qualification conversion, producing an lvalue.
667  /// \brief Perform a conversion adding _Atomic to a type.
669  /// \brief Perform a load from a glvalue, producing an rvalue.
671  /// \brief Perform an implicit conversion sequence.
673  /// \brief Perform an implicit conversion sequence without narrowing.
675  /// \brief Perform list-initialization without a constructor.
677  /// \brief Unwrap the single-element initializer list for a reference.
679  /// \brief Rewrap the single-element initializer list for a reference.
681  /// \brief Perform initialization via a constructor.
683  /// \brief Perform initialization via a constructor, taking arguments from
684  /// a single InitListExpr.
686  /// \brief Zero-initialize the object
688  /// \brief C assignment
690  /// \brief Initialization by string
692  /// \brief An initialization that "converts" an Objective-C object
693  /// (not a point to an object) to another Objective-C object type.
695  /// \brief Array initialization (from an array rvalue).
696  /// This is a GNU C extension.
698  /// \brief Array initialization from a parenthesized initializer list.
699  /// This is a GNU C++ extension.
701  /// \brief Pass an object by indirect copy-and-restore.
703  /// \brief Pass an object by indirect restore.
705  /// \brief Produce an Objective-C object pointer.
707  /// \brief Construct a std::initializer_list from an initializer list.
709  /// \brief Perform initialization via a constructor taking a single
710  /// std::initializer_list argument.
712  /// \brief Initialize an OpenCL sampler from an integer.
714  /// \brief Passing zero to a function where OpenCL event_t is expected.
716  };
717 
718  /// \brief A single step in the initialization sequence.
719  class Step {
720  public:
721  /// \brief The kind of conversion or initialization step we are taking.
723 
724  // \brief The type that results from this initialization.
726 
727  struct F {
731  };
732 
733  union {
734  /// \brief When Kind == SK_ResolvedOverloadedFunction or Kind ==
735  /// SK_UserConversion, the function that the expression should be
736  /// resolved to or the conversion function to call, respectively.
737  /// When Kind == SK_ConstructorInitialization or SK_ListConstruction,
738  /// the constructor to be called.
739  ///
740  /// Always a FunctionDecl, plus a Boolean flag telling if it was
741  /// selected from an overloaded set having size greater than 1.
742  /// For conversion decls, the naming class is the source type.
743  /// For construct decls, the naming class is the target type.
744  struct F Function;
745 
746  /// \brief When Kind = SK_ConversionSequence, the implicit conversion
747  /// sequence.
749 
750  /// \brief When Kind = SK_RewrapInitList, the syntactic form of the
751  /// wrapping list.
753  };
754 
755  void Destroy();
756  };
757 
758 private:
759  /// \brief The kind of initialization sequence computed.
761 
762  /// \brief Steps taken by this initialization.
763  SmallVector<Step, 4> Steps;
764 
765 public:
766  /// \brief Describes why initialization failed.
767  enum FailureKind {
768  /// \brief Too many initializers provided for a reference.
770  /// \brief Array must be initialized with an initializer list.
772  /// \brief Array must be initialized with an initializer list or a
773  /// string literal.
775  /// \brief Array must be initialized with an initializer list or a
776  /// wide string literal.
778  /// \brief Initializing a wide char array with narrow string literal.
780  /// \brief Initializing char array with wide string literal.
782  /// \brief Initializing wide char array with incompatible wide string
783  /// literal.
785  /// \brief Array type mismatch.
787  /// \brief Non-constant array initializer
789  /// \brief Cannot resolve the address of an overloaded function.
791  /// \brief Overloading due to reference initialization failed.
793  /// \brief Non-const lvalue reference binding to a temporary.
795  /// \brief Non-const lvalue reference binding to an lvalue of unrelated
796  /// type.
798  /// \brief Rvalue reference binding to an lvalue.
800  /// \brief Reference binding drops qualifiers.
802  /// \brief Reference binding failed.
804  /// \brief Implicit conversion failed.
806  /// \brief Implicit conversion failed.
808  /// \brief Too many initializers for scalar
810  /// \brief Reference initialization from an initializer list
812  /// \brief Initialization of some unused destination type with an
813  /// initializer list.
815  /// \brief Overloading for a user-defined conversion failed.
817  /// \brief Overloading for initialization by constructor failed.
819  /// \brief Overloading for list-initialization by constructor failed.
821  /// \brief Default-initialization of a 'const' object.
823  /// \brief Initialization of an incomplete type.
825  /// \brief Variable-length array must not have an initializer.
827  /// \brief List initialization failed at some point.
829  /// \brief Initializer has a placeholder type which cannot be
830  /// resolved by initialization.
832  /// \brief Trying to take the address of a function that doesn't support
833  /// having its address taken.
835  /// \brief List-copy-initialization chose an explicit constructor.
837  };
838 
839 private:
840  /// \brief The reason why initialization failed.
841  FailureKind Failure;
842 
843  /// \brief The failed result of overload resolution.
844  OverloadingResult FailedOverloadResult;
845 
846  /// \brief The candidate set created when initialization failed.
847  OverloadCandidateSet FailedCandidateSet;
848 
849  /// \brief The incomplete type that caused a failure.
850  QualType FailedIncompleteType;
851 
852  /// \brief The fixit that needs to be applied to make this initialization
853  /// succeed.
854  std::string ZeroInitializationFixit;
855  SourceLocation ZeroInitializationFixitLoc;
856 
857 public:
858  /// \brief Call for initializations are invalid but that would be valid
859  /// zero initialzations if Fixit was applied.
860  void SetZeroInitializationFixit(const std::string& Fixit, SourceLocation L) {
861  ZeroInitializationFixit = Fixit;
862  ZeroInitializationFixitLoc = L;
863  }
864 
865 private:
866 
867  /// \brief Prints a follow-up note that highlights the location of
868  /// the initialized entity, if it's remote.
869  void PrintInitLocationNote(Sema &S, const InitializedEntity &Entity);
870 
871 public:
872  /// \brief Try to perform initialization of the given entity, creating a
873  /// record of the steps required to perform the initialization.
874  ///
875  /// The generated initialization sequence will either contain enough
876  /// information to diagnose
877  ///
878  /// \param S the semantic analysis object.
879  ///
880  /// \param Entity the entity being initialized.
881  ///
882  /// \param Kind the kind of initialization being performed.
883  ///
884  /// \param Args the argument(s) provided for initialization.
885  ///
886  /// \param TopLevelOfInitList true if we are initializing from an expression
887  /// at the top level inside an initializer list. This disallows
888  /// narrowing conversions in C++11 onwards.
889  /// \param TreatUnavailableAsInvalid true if we want to treat unavailable
890  /// as invalid.
892  const InitializedEntity &Entity,
893  const InitializationKind &Kind,
894  MultiExprArg Args,
895  bool TopLevelOfInitList = false,
896  bool TreatUnavailableAsInvalid = true);
897  void InitializeFrom(Sema &S, const InitializedEntity &Entity,
898  const InitializationKind &Kind, MultiExprArg Args,
899  bool TopLevelOfInitList, bool TreatUnavailableAsInvalid);
900 
902 
903  /// \brief Perform the actual initialization of the given entity based on
904  /// the computed initialization sequence.
905  ///
906  /// \param S the semantic analysis object.
907  ///
908  /// \param Entity the entity being initialized.
909  ///
910  /// \param Kind the kind of initialization being performed.
911  ///
912  /// \param Args the argument(s) provided for initialization, ownership of
913  /// which is transferred into the routine.
914  ///
915  /// \param ResultType if non-NULL, will be set to the type of the
916  /// initialized object, which is the type of the declaration in most
917  /// cases. However, when the initialized object is a variable of
918  /// incomplete array type and the initializer is an initializer
919  /// list, this type will be set to the completed array type.
920  ///
921  /// \returns an expression that performs the actual object initialization, if
922  /// the initialization is well-formed. Otherwise, emits diagnostics
923  /// and returns an invalid expression.
925  const InitializedEntity &Entity,
926  const InitializationKind &Kind,
927  MultiExprArg Args,
928  QualType *ResultType = nullptr);
929 
930  /// \brief Diagnose an potentially-invalid initialization sequence.
931  ///
932  /// \returns true if the initialization sequence was ill-formed,
933  /// false otherwise.
934  bool Diagnose(Sema &S,
935  const InitializedEntity &Entity,
936  const InitializationKind &Kind,
937  ArrayRef<Expr *> Args);
938 
939  /// \brief Determine the kind of initialization sequence computed.
940  enum SequenceKind getKind() const { return SequenceKind; }
941 
942  /// \brief Set the kind of sequence computed.
943  void setSequenceKind(enum SequenceKind SK) { SequenceKind = SK; }
944 
945  /// \brief Determine whether the initialization sequence is valid.
946  explicit operator bool() const { return !Failed(); }
947 
948  /// \brief Determine whether the initialization sequence is invalid.
949  bool Failed() const { return SequenceKind == FailedSequence; }
950 
952  step_iterator step_begin() const { return Steps.begin(); }
953  step_iterator step_end() const { return Steps.end(); }
954 
955  typedef llvm::iterator_range<step_iterator> step_range;
956  step_range steps() const { return {step_begin(), step_end()}; }
957 
958  /// \brief Determine whether this initialization is a direct reference
959  /// binding (C++ [dcl.init.ref]).
960  bool isDirectReferenceBinding() const;
961 
962  /// \brief Determine whether this initialization failed due to an ambiguity.
963  bool isAmbiguous() const;
964 
965  /// \brief Determine whether this initialization is direct call to a
966  /// constructor.
967  bool isConstructorInitialization() const;
968 
969  /// \brief Returns whether the last step in this initialization sequence is a
970  /// narrowing conversion, defined by C++0x [dcl.init.list]p7.
971  ///
972  /// If this function returns true, *isInitializerConstant will be set to
973  /// describe whether *Initializer was a constant expression. If
974  /// *isInitializerConstant is set to true, *ConstantValue will be set to the
975  /// evaluated value of *Initializer.
976  bool endsWithNarrowing(ASTContext &Ctx, const Expr *Initializer,
977  bool *isInitializerConstant,
978  APValue *ConstantValue) const;
979 
980  /// \brief Add a new step in the initialization that resolves the address
981  /// of an overloaded function to a specific function declaration.
982  ///
983  /// \param Function the function to which the overloaded function reference
984  /// resolves.
986  DeclAccessPair Found,
987  bool HadMultipleCandidates);
988 
989  /// \brief Add a new step in the initialization that performs a derived-to-
990  /// base cast.
991  ///
992  /// \param BaseType the base type to which we will be casting.
993  ///
994  /// \param Category Indicates whether the result will be treated as an
995  /// rvalue, an xvalue, or an lvalue.
996  void AddDerivedToBaseCastStep(QualType BaseType,
998 
999  /// \brief Add a new step binding a reference to an object.
1000  ///
1001  /// \param BindingTemporary True if we are binding a reference to a temporary
1002  /// object (thereby extending its lifetime); false if we are binding to an
1003  /// lvalue or an lvalue treated as an rvalue.
1004  void AddReferenceBindingStep(QualType T, bool BindingTemporary);
1005 
1006  /// \brief Add a new step that makes an extraneous copy of the input
1007  /// to a temporary of the same class type.
1008  ///
1009  /// This extraneous copy only occurs during reference binding in
1010  /// C++98/03, where we are permitted (but not required) to introduce
1011  /// an extra copy. At a bare minimum, we must check that we could
1012  /// call the copy constructor, and produce a diagnostic if the copy
1013  /// constructor is inaccessible or no copy constructor matches.
1014  //
1015  /// \param T The type of the temporary being created.
1017 
1018  /// \brief Add a new step invoking a conversion function, which is either
1019  /// a constructor or a conversion function.
1020  void AddUserConversionStep(FunctionDecl *Function,
1021  DeclAccessPair FoundDecl,
1022  QualType T,
1023  bool HadMultipleCandidates);
1024 
1025  /// \brief Add a new step that performs a qualification conversion to the
1026  /// given type.
1029 
1030  /// \brief Add a new step that performs conversion from non-atomic to atomic
1031  /// type.
1033 
1034  /// \brief Add a new step that performs a load of the given type.
1035  ///
1036  /// Although the term "LValueToRValue" is conventional, this applies to both
1037  /// lvalues and xvalues.
1039 
1040  /// \brief Add a new step that applies an implicit conversion sequence.
1042  QualType T, bool TopLevelOfInitList = false);
1043 
1044  /// \brief Add a list-initialization step.
1046 
1047  /// \brief Add a constructor-initialization step.
1048  ///
1049  /// \param FromInitList The constructor call is syntactically an initializer
1050  /// list.
1051  /// \param AsInitList The constructor is called as an init list constructor.
1053  CXXConstructorDecl *Constructor,
1054  QualType T,
1055  bool HadMultipleCandidates,
1056  bool FromInitList, bool AsInitList);
1057 
1058  /// \brief Add a zero-initialization step.
1060 
1061  /// \brief Add a C assignment step.
1062  //
1063  // FIXME: It isn't clear whether this should ever be needed;
1064  // ideally, we would handle everything needed in C in the common
1065  // path. However, that isn't the case yet.
1066  void AddCAssignmentStep(QualType T);
1067 
1068  /// \brief Add a string init step.
1069  void AddStringInitStep(QualType T);
1070 
1071  /// \brief Add an Objective-C object conversion step, which is
1072  /// always a no-op.
1074 
1075  /// \brief Add an array initialization step.
1076  void AddArrayInitStep(QualType T);
1077 
1078  /// \brief Add a parenthesized array initialization step.
1080 
1081  /// \brief Add a step to pass an object by indirect copy-restore.
1082  void AddPassByIndirectCopyRestoreStep(QualType T, bool shouldCopy);
1083 
1084  /// \brief Add a step to "produce" an Objective-C object (by
1085  /// retaining it).
1087 
1088  /// \brief Add a step to construct a std::initializer_list object from an
1089  /// initializer list.
1091 
1092  /// \brief Add a step to initialize an OpenCL sampler from an integer
1093  /// constant.
1095 
1096  /// \brief Add a step to initialize an OpenCL event_t from a NULL
1097  /// constant.
1098  void AddOCLZeroEventStep(QualType T);
1099 
1100  /// \brief Add steps to unwrap a initializer list for a reference around a
1101  /// single element and rewrap it at the end.
1102  void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic);
1103 
1104  /// \brief Note that this initialization sequence failed.
1105  void SetFailed(FailureKind Failure) {
1107  this->Failure = Failure;
1108  assert((Failure != FK_Incomplete || !FailedIncompleteType.isNull()) &&
1109  "Incomplete type failure requires a type!");
1110  }
1111 
1112  /// \brief Note that this initialization sequence failed due to failed
1113  /// overload resolution.
1115 
1116  /// \brief Retrieve a reference to the candidate set when overload
1117  /// resolution fails.
1119  return FailedCandidateSet;
1120  }
1121 
1122  /// \brief Get the overloading result, for when the initialization
1123  /// sequence failed due to a bad overload.
1125  return FailedOverloadResult;
1126  }
1127 
1128  /// \brief Note that this initialization sequence failed due to an
1129  /// incomplete type.
1130  void setIncompleteTypeFailure(QualType IncompleteType) {
1131  FailedIncompleteType = IncompleteType;
1133  }
1134 
1135  /// \brief Determine why initialization failed.
1137  assert(Failed() && "Not an initialization failure!");
1138  return Failure;
1139  }
1140 
1141  /// \brief Dump a representation of this initialization sequence to
1142  /// the given stream, for debugging purposes.
1143  void dump(raw_ostream &OS) const;
1144 
1145  /// \brief Dump a representation of this initialization sequence to
1146  /// standard error, for debugging purposes.
1147  void dump() const;
1148 };
1149 
1150 } // end namespace clang
1151 
1152 #endif // LLVM_CLANG_SEMA_INITIALIZATION_H
Perform a derived-to-base cast, producing an lvalue.
Defines the clang::ASTContext interface.
SourceLocation getEnd() const
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1561
InitListExpr * WrappingSyntacticList
When Kind = SK_RewrapInitList, the syntactic form of the wrapping list.
bool Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr * > Args)
Diagnose an potentially-invalid initialization sequence.
Definition: SemaInit.cpp:7044
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:598
unsigned Index
When Kind == EK_ArrayElement, EK_VectorElement, or EK_ComplexElement, the index of the array or vecto...
step_iterator step_end() const
bool endsWithNarrowing(ASTContext &Ctx, const Expr *Initializer, bool *isInitializerConstant, APValue *ConstantValue) const
Returns whether the last step in this initialization sequence is a narrowing conversion, defined by C++0x [dcl.init.list]p7.
Produce an Objective-C object pointer.
void AddOCLZeroEventStep(QualType T)
Add a step to initialize an OpenCL event_t from a NULL constant.
Definition: SemaInit.cpp:3313
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.
SmallVectorImpl< Step >::const_iterator step_iterator
C Language Family Type Representation.
uintptr_t Base
When Kind == EK_Base, the base specifier that provides the base class.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
The base class of the type hierarchy.
Definition: Type.h:1281
SourceLocation getEqualLoc() const
Retrieve the location of the equal sign for copy initialization (if present).
The entity being initialized is a variable.
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
Overloading for a user-defined conversion failed.
A container of type source information.
Definition: Decl.h:62
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:3121
Perform a derived-to-base cast, producing an xvalue.
The entity being initialized is a base member subobject.
bool isFunctionalCast() const
Determine whether this is a functional-style cast.
List-copy-initialization chose an explicit constructor.
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2187
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.
EntityKind getKind() const
Determine the kind of initialization.
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:2874
QualType getVariableArrayDecayedType(QualType Ty) const
Returns a vla type where known sizes are replaced with [*].
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:768
void AddCAssignmentStep(QualType T)
Add a C assignment step.
Definition: SemaInit.cpp:3248
llvm::iterator_range< step_iterator > step_range
SourceRange getParenRange() const
Retrieve the source range containing the locations of the open and closing parentheses for value and ...
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
Non-const lvalue reference binding to an lvalue of unrelated type.
step_iterator step_begin() const
static InitializedEntity InitializeResult(SourceLocation ReturnLoc, QualType Type, bool NRVO)
Create the initialization entity for the result of a function.
SourceLocation getThrowLoc() const
Determine the location of the 'throw' keyword when initializing an exception object.
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:3145
static InitializationKind CreateDirectList(SourceLocation InitLoc)
bool allowsNRVO() const
Determine whether this initialization allows the named return value optimization, which also applies ...
Definition: SemaInit.cpp:2951
void setElementIndex(unsigned Index)
If this is already the initializer for an array or vector element, sets the element index...
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1377
The entity being initialized is a temporary object.
bool allowExplicitConversionFunctionsInRefBinding() const
Retrieve whether this initialization allows the use of explicit conversion functions when binding a r...
Construct a std::initializer_list from an initializer list.
Trying to take the address of a function that doesn't support having its address taken.
One of these records is kept for each identifier that is lexed.
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:3320
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init.ref]).
Definition: SemaInit.cpp:3067
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:92
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.
DeclaratorDecl * getDecl() const
Retrieve the variable, parameter, or field being initialized.
Definition: SemaInit.cpp:2922
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2293
SourceLocation getReturnLoc() const
Determine the location of the 'return' keyword when initializing the result of a function call...
Rewrap the single-element initializer list for a reference.
void AddOCLSamplerInitStep(QualType T)
Add a step to initialize an OpenCL sampler from an integer constant.
Definition: SemaInit.cpp:3306
int Category
Definition: Format.cpp:1197
TypeSourceInfo * getTypeSourceInfo() const
Retrieve complete type-source information for the object being constructed, if known.
void SetOverloadFailure(FailureKind Failure, OverloadingResult Result)
Note that this initialization sequence failed due to failed overload resolution.
Definition: SemaInit.cpp:3335
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:3746
static InitializedEntity InitializeTemporary(TypeSourceInfo *TypeInfo)
Create the initialization entity for a temporary.
const LangOptions & getLangOpts() const
Definition: ASTContext.h:604
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.
SourceRange getRange() const
Retrieve the source range that covers the initialization.
OverloadCandidateSet & getFailedCandidateSet()
Retrieve a reference to the candidate set when overload resolution fails.
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:4917
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.
void AddParenthesizedArrayInitStep(QualType T)
Add a parenthesized array initialization step.
Definition: SemaInit.cpp:3276
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:6208
The entity being initialized is an element of a vector.
bool isAmbiguous() const
Determine whether this initialization failed due to an ambiguity.
Definition: SemaInit.cpp:3071
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.
QualType getType() const
Definition: Decl.h:599
static InitializedEntity InitializeNew(SourceLocation NewLoc, QualType Type)
Create the initialization entity for an object allocated via new.
Perform an implicit conversion sequence.
bool isInheritedVirtualBase() const
Return whether the base is an inherited virtual base.
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:263
Overloading for list-initialization by constructor failed.
Perform list-initialization without a constructor.
void AddObjCObjectConversionStep(QualType T)
Add an Objective-C object conversion step, which is always a no-op.
Definition: SemaInit.cpp:3262
Cannot resolve the address of an overloaded function.
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:646
void AddStdInitializerListConstructionStep(QualType T)
Add a step to construct a std::initializer_list object from an initializer list.
Definition: SemaInit.cpp:3299
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a member subobject.
FieldDecl * getAnonField() const
Definition: Decl.h:2548
ASTContext * Context
The entity being initialized is a field of block descriptor for the copied-in c++ object...
Initializing wide char array with incompatible wide string literal.
The entity being initialized is the real or imaginary part of a complex number.
friend class ASTContext
Definition: Type.h:4178
Expr - This represents one expression.
Definition: Expr.h:105
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:102
static InitializationKind CreateFunctionalCast(SourceRange TypeRange, bool InitList)
Create a direct initialization for a functional cast.
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.
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
Initializing a wide char array with narrow string literal.
void AddProduceObjCObjectStep(QualType T)
Add a step to "produce" an Objective-C object (by retaining it).
Definition: SemaInit.cpp:3292
Passing zero to a function where OpenCL event_t is expected.
#define bool
Definition: stdbool.h:31
Resolve the address of an overloaded function to a specific function declaration. ...
void AddArrayInitStep(QualType T)
Add an array initialization step.
Definition: SemaInit.cpp:3269
The entity being initialized is an exception object that is being thrown.
struct F Function
When Kind == SK_ResolvedOverloadedFunction or Kind == SK_UserConversion, the function that the expres...
ObjCMethodDecl * getMethodDecl() const
Retrieve the ObjectiveC method being initialized.
Initializer has a placeholder type which cannot be resolved by initialization.
FailureKind getFailureKind() const
Determine why initialization failed.
void AddStringInitStep(QualType T)
Add a string init step.
Definition: SemaInit.cpp:3255
The result type of a method or function.
InitKind getKind() const
Determine the initialization kind.
__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:75
void AddZeroInitializationStep(QualType T)
Add a zero-initialization step.
Definition: SemaInit.cpp:3241
static InitializedEntity InitializeMember(IndirectFieldDecl *Member, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a member subobject.
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.
void AddListInitializationStep(QualType T)
Add a list-initialization step.
Definition: SemaInit.cpp:3220
Perform a qualification conversion, producing an lvalue.
void AddLValueToRValueStep(QualType Ty)
Add a new step that performs a load of the given type.
Definition: SemaInit.cpp:3200
Kind
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Definition: Overload.h:376
SequenceKind
Describes the kind of initialization sequence computed.
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.
SourceLocation getLocation() const
Retrieve the location at which initialization is occurring.
SourceLocation getCaptureLoc() const
Determine the location of the capture when initializing field from a captured variable in a lambda...
StepKind
Describes the kind of a particular step in an initialization sequence.
TypeSourceInfo * TypeInfo
When Kind == EK_Temporary or EK_CompoundLiteralInit, the type source information for the temporary...
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm, QualType Type)
Create the initialization entity for a parameter, but use another type.
OverloadingResult
OverloadingResult - Capture the result of performing overload resolution.
Definition: Overload.h:40
static InitializedEntity InitializeElement(ASTContext &Context, unsigned Index, const InitializedEntity &Parent)
Create the initialization entity for an array element.
bool isExplicitCast() const
Determine whether this initialization is an explicit cast.
const InitializedEntity * getParent() const
Retrieve the parent of the entity being initialized, when the initialization itself is occurring with...
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.
void InitializeFrom(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, bool TopLevelOfInitList, bool TreatUnavailableAsInvalid)
Definition: SemaInit.cpp:4939
The entity being implicitly initialized back to the formal result type.
The entity being initialized is the initializer for a compound literal.
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:3153
Describes the kind of initialization being performed, along with location information for tokens rela...
The entity being initialized is an element of an array.
StringRef getCapturedVarName() const
For a lambda capture, return the capture's name.
bool isCStyleOrFunctionalCast() const
Determine whether this initialization is a C-style cast.
Overloading for initialization by constructor failed.
SourceLocation getBegin() const
An optional copy of a temporary object to another temporary object, which is permitted (but not requi...
void AddAtomicConversionStep(QualType Ty)
Add a new step that performs conversion from non-atomic to atomic type.
Definition: SemaInit.cpp:3193
void AddPassByIndirectCopyRestoreStep(QualType T, bool shouldCopy)
Add a step to pass an object by indirect copy-restore.
Definition: SemaInit.cpp:3283
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:701
enum SequenceKind getKind() const
Determine the kind of initialization sequence computed.
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:70
static InitializationKind CreateCast(SourceRange TypeRange)
Create a direct initialization due to a cast that isn't a C-style or functional cast.
Pass an object by indirect copy-and-restore.
A POD class for pairing a NamedDecl* with an access specifier.
void SetFailed(FailureKind Failure)
Note that this initialization sequence failed.
bool isCStyleCast() const
Determine whether this is a C-style cast.
Array must be initialized with an initializer list or a string literal.
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.
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2521
DeclarationName - The name of a declaration.
DeclaratorDecl * VariableOrMember
When Kind == EK_Variable, or EK_Member, the VarDecl or FieldDecl, respectively.
static InitializationKind CreateCStyleCast(SourceLocation StartLoc, SourceRange TypeRange, bool InitList)
Create a direct initialization for a C-style cast.
Overloading due to reference initialization failed.
bool isParameterKind() const
const CXXBaseSpecifier * getBaseSpecifier() const
Retrieve the base specifier.
Array must be initialized with an initializer list.
bool isParameterConsumed() const
Determine whether this initialization consumes the parameter.
void AddDerivedToBaseCastStep(QualType BaseType, ExprValueKind Category)
Add a new step in the initialization that performs a derived-to- base cast.
Definition: SemaInit.cpp:3133
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:159
QualType getType() const
Retrieve type being initialized.
OverloadingResult getFailedOverloadResult() const
Get the overloading result, for when the initialization sequence failed due to a bad overload...
bool AllowExplicit() const
Retrieve whether this initialization allows the use of explicit constructors.
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:3161
bool Failed() const
Determine whether the initialization sequence is invalid.
void dump() const
Dump a representation of the initialized entity to standard error, for debugging purposes.
Definition: SemaInit.cpp:3018
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:5339
Perform initialization via a constructor, taking arguments from a single InitListExpr.
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 isImplicitValueInit() const
Determine whether this initialization is an implicit value-initialization, e.g., as occurs during agg...
unsigned allocateManglingNumber() const
ObjCMethodDecl * MethodDecl
When Kind == EK_RelatedResult, the ObjectiveC method where result type was implicitly changed to acco...
DeclarationName getName() const
Retrieve the name of the entity being initialized.
Definition: SemaInit.cpp:2889
void AddConstructorInitializationStep(DeclAccessPair FoundDecl, CXXConstructorDecl *Constructor, QualType T, bool HadMultipleCandidates, bool FromInitList, bool AsInitList)
Add a constructor-initialization step.
Definition: SemaInit.cpp:3227
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:3174
bool isConstructorInitialization() const
Determine whether this initialization is direct call to a constructor.
Definition: SemaInit.cpp:3115
A failed initialization sequence.
Array initialization (from an array rvalue).
InitKind
The kind of initialization being performed.
Default-initialization of a 'const' object.
void AddConversionSequenceStep(const ImplicitConversionSequence &ICS, QualType T, bool TopLevelOfInitList=false)
Add a new step that applies an implicit conversion sequence.
Definition: SemaInit.cpp:3209
A trivial tuple used to represent a source range.
void dump() const
Dump a representation of this initialization sequence to standard error, for debugging purposes...
Definition: SemaInit.cpp:7724
unsigned getElementIndex() const
If this is an array, vector, or complex number element, get the element's index.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:665
Describes an entity that is being initialized.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
Direct list-initialization.
Array initialization from a parenthesized initializer list.