clang 17.0.0git
Initialization.h
Go to the documentation of this file.
1//===- Initialization.h - Semantic Analysis for Initializers ----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file provides supporting data types for initialization of objects.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_SEMA_INITIALIZATION_H
14#define LLVM_CLANG_SEMA_INITIALIZATION_H
15
17#include "clang/AST/Attr.h"
18#include "clang/AST/Decl.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/Type.h"
24#include "clang/Basic/LLVM.h"
28#include "clang/Sema/Overload.h"
30#include "llvm/ADT/ArrayRef.h"
31#include "llvm/ADT/SmallVector.h"
32#include "llvm/ADT/StringRef.h"
33#include "llvm/ADT/iterator_range.h"
34#include "llvm/Support/Casting.h"
35#include <cassert>
36#include <cstdint>
37#include <string>
38
39namespace clang {
40
41class CXXBaseSpecifier;
42class CXXConstructorDecl;
43class ObjCMethodDecl;
44class Sema;
45
46/// Describes an entity that is being initialized.
47class alignas(8) InitializedEntity {
48public:
49 /// Specifies the kind of entity being initialized.
51 /// The entity being initialized is a variable.
53
54 /// The entity being initialized is a function parameter.
56
57 /// The entity being initialized is a non-type template parameter.
59
60 /// The entity being initialized is the result of a function call.
62
63 /// The entity being initialized is the result of a statement expression.
65
66 /// The entity being initialized is an exception object that
67 /// is being thrown.
69
70 /// The entity being initialized is a non-static data member
71 /// subobject.
73
74 /// The entity being initialized is an element of an array.
76
77 /// The entity being initialized is an object (or array of
78 /// objects) allocated via new.
80
81 /// The entity being initialized is a temporary object.
83
84 /// The entity being initialized is a base member subobject.
86
87 /// The initialization is being done by a delegating constructor.
89
90 /// The entity being initialized is an element of a vector.
91 /// or vector.
93
94 /// The entity being initialized is a field of block descriptor for
95 /// the copied-in c++ object.
97
98 /// The entity being initialized is a field of block descriptor for the
99 /// copied-in lambda object that's used in the lambda to block conversion.
101
102 /// The entity being initialized is the real or imaginary part of a
103 /// complex number.
105
106 /// The entity being initialized is the field that captures a
107 /// variable in a lambda.
109
110 /// The entity being initialized is the initializer for a compound
111 /// literal.
113
114 /// The entity being implicitly initialized back to the formal
115 /// result type.
117
118 /// The entity being initialized is a function parameter; function
119 /// is member of group of audited CF APIs.
121
122 /// The entity being initialized is a structured binding of a
123 /// decomposition declaration.
125
126 // Note: err_init_conversion_failed in DiagnosticSemaKinds.td uses this
127 // enum as an index for its first %select. When modifying this list,
128 // that diagnostic text needs to be updated as well.
129 };
130
131private:
132 /// The kind of entity being initialized.
133 EntityKind Kind;
134
135 /// If non-NULL, the parent entity in which this
136 /// initialization occurs.
137 const InitializedEntity *Parent = nullptr;
138
139 /// The type of the object or reference being initialized.
141
142 /// The mangling number for the next reference temporary to be created.
143 mutable unsigned ManglingNumber = 0;
144
145 struct LN {
146 /// When Kind == EK_Result, EK_Exception, EK_New, the
147 /// location of the 'return', 'throw', or 'new' keyword,
148 /// respectively. When Kind == EK_Temporary, the location where
149 /// the temporary is being created.
150 SourceLocation Location;
151
152 /// Whether the entity being initialized may end up using the
153 /// named return value optimization (NRVO).
154 bool NRVO;
155 };
156
157 struct VD {
158 /// The VarDecl, FieldDecl, or BindingDecl being initialized.
159 ValueDecl *VariableOrMember;
160
161 /// When Kind == EK_Member, whether this is an implicit member
162 /// initialization in a copy or move constructor. These can perform array
163 /// copies.
164 bool IsImplicitFieldInit;
165
166 /// When Kind == EK_Member, whether this is the initial initialization
167 /// check for a default member initializer.
168 bool IsDefaultMemberInit;
169 };
170
171 struct C {
172 /// The name of the variable being captured by an EK_LambdaCapture.
173 IdentifierInfo *VarID;
174
175 /// The source location at which the capture occurs.
176 SourceLocation Location;
177 };
178
179 union {
180 /// When Kind == EK_Variable, EK_Member, EK_Binding, or
181 /// EK_TemplateParameter, the variable, binding, or template parameter.
183
184 /// When Kind == EK_RelatedResult, the ObjectiveC method where
185 /// result type was implicitly changed to accommodate ARC semantics.
187
188 /// When Kind == EK_Parameter, the ParmVarDecl, with the
189 /// integer indicating whether the parameter is "consumed".
190 llvm::PointerIntPair<ParmVarDecl *, 1> Parameter;
191
192 /// When Kind == EK_Temporary or EK_CompoundLiteralInit, the type
193 /// source information for the temporary.
195
196 struct LN LocAndNRVO;
197
198 /// When Kind == EK_Base, the base specifier that provides the
199 /// base class. The integer specifies whether the base is an inherited
200 /// virtual base.
201 llvm::PointerIntPair<const CXXBaseSpecifier *, 1> Base;
202
203 /// When Kind == EK_ArrayElement, EK_VectorElement, or
204 /// EK_ComplexElement, the index of the array or vector element being
205 /// initialized.
206 unsigned Index;
207
208 struct C Capture;
209 };
210
212
213 /// Create the initialization entity for a variable.
214 InitializedEntity(VarDecl *Var, EntityKind EK = EK_Variable)
215 : Kind(EK), Type(Var->getType()), Variable{Var, false, false} {}
216
217 /// Create the initialization entity for the result of a
218 /// function, throwing an object, performing an explicit cast, or
219 /// initializing a parameter for which there is no declaration.
220 InitializedEntity(EntityKind Kind, SourceLocation Loc, QualType Type,
221 bool NRVO = false)
222 : Kind(Kind), Type(Type) {
223 new (&LocAndNRVO) LN;
224 LocAndNRVO.Location = Loc;
225 LocAndNRVO.NRVO = NRVO;
226 }
227
228 /// Create the initialization entity for a member subobject.
229 InitializedEntity(FieldDecl *Member, const InitializedEntity *Parent,
230 bool Implicit, bool DefaultMemberInit)
232 Variable{Member, Implicit, DefaultMemberInit} {}
233
234 /// Create the initialization entity for an array element.
235 InitializedEntity(ASTContext &Context, unsigned Index,
236 const InitializedEntity &Parent);
237
238 /// Create the initialization entity for a lambda capture.
239 InitializedEntity(IdentifierInfo *VarID, QualType FieldType, SourceLocation Loc)
240 : Kind(EK_LambdaCapture), Type(FieldType) {
241 new (&Capture) C;
242 Capture.VarID = VarID;
243 Capture.Location = Loc;
244 }
245
246public:
247 /// Create the initialization entity for a variable.
249 return InitializedEntity(Var);
250 }
251
252 /// Create the initialization entity for a parameter.
254 ParmVarDecl *Parm) {
255 return InitializeParameter(Context, Parm, Parm->getType());
256 }
257
258 /// Create the initialization entity for a parameter, but use
259 /// another type.
260 static InitializedEntity
262 bool Consumed = (Context.getLangOpts().ObjCAutoRefCount &&
263 Parm->hasAttr<NSConsumedAttr>());
264
265 InitializedEntity Entity;
266 Entity.Kind = EK_Parameter;
267 Entity.Type =
268 Context.getVariableArrayDecayedType(Type.getUnqualifiedType());
269 Entity.Parent = nullptr;
270 Entity.Parameter = {Parm, Consumed};
271 return Entity;
272 }
273
274 /// Create the initialization entity for a parameter that is
275 /// only known by its type.
278 bool Consumed) {
279 InitializedEntity Entity;
280 Entity.Kind = EK_Parameter;
281 Entity.Type = Context.getVariableArrayDecayedType(Type);
282 Entity.Parent = nullptr;
283 Entity.Parameter = {nullptr, Consumed};
284 return Entity;
285 }
286
287 /// Create the initialization entity for a template parameter.
288 static InitializedEntity
290 InitializedEntity Entity;
291 Entity.Kind = EK_TemplateParameter;
292 Entity.Type = T;
293 Entity.Parent = nullptr;
294 Entity.Variable = {Param, false, false};
295 return Entity;
296 }
297
298 /// Create the initialization entity for the result of a function.
300 QualType Type) {
301 return InitializedEntity(EK_Result, ReturnLoc, Type);
302 }
303
305 QualType Type) {
306 return InitializedEntity(EK_StmtExprResult, ReturnLoc, Type);
307 }
308
310 QualType Type) {
311 return InitializedEntity(EK_BlockElement, BlockVarLoc, Type);
312 }
313
315 QualType Type) {
317 BlockVarLoc, Type);
318 }
319
320 /// Create the initialization entity for an exception object.
322 QualType Type) {
323 return InitializedEntity(EK_Exception, ThrowLoc, Type);
324 }
325
326 /// Create the initialization entity for an object allocated via new.
328 return InitializedEntity(EK_New, NewLoc, Type);
329 }
330
331 /// Create the initialization entity for a temporary.
333 return InitializeTemporary(nullptr, Type);
334 }
335
336 /// Create the initialization entity for a temporary.
339 QualType Type = TypeInfo->getType();
340 if (Context.getLangOpts().OpenCLCPlusPlus) {
341 assert(!Type.hasAddressSpace() && "Temporary already has address space!");
342 Type = Context.getAddrSpaceQualType(Type, LangAS::opencl_private);
343 }
344
346 }
347
348 /// Create the initialization entity for a temporary.
350 QualType Type) {
352 Result.TypeInfo = TypeInfo;
353 return Result;
354 }
355
356 /// Create the initialization entity for a related result.
358 QualType Type) {
360 Result.MethodDecl = MD;
361 return Result;
362 }
363
364 /// Create the initialization entity for a base class subobject.
365 static InitializedEntity
367 bool IsInheritedVirtualBase,
368 const InitializedEntity *Parent = nullptr);
369
370 /// Create the initialization entity for a delegated constructor.
373 }
374
375 /// Create the initialization entity for a member subobject.
376 static InitializedEntity
378 const InitializedEntity *Parent = nullptr,
379 bool Implicit = false) {
380 return InitializedEntity(Member, Parent, Implicit, false);
381 }
382
383 /// Create the initialization entity for a member subobject.
384 static InitializedEntity
386 const InitializedEntity *Parent = nullptr,
387 bool Implicit = false) {
388 return InitializedEntity(Member->getAnonField(), Parent, Implicit, false);
389 }
390
391 /// Create the initialization entity for a default member initializer.
392 static InitializedEntity
394 return InitializedEntity(Member, nullptr, false, true);
395 }
396
397 /// Create the initialization entity for an array element.
399 unsigned Index,
400 const InitializedEntity &Parent) {
401 return InitializedEntity(Context, Index, Parent);
402 }
403
404 /// Create the initialization entity for a structured binding.
406 return InitializedEntity(Binding, EK_Binding);
407 }
408
409 /// Create the initialization entity for a lambda capture.
410 ///
411 /// \p VarID The name of the entity being captured, or nullptr for 'this'.
413 QualType FieldType,
414 SourceLocation Loc) {
415 return InitializedEntity(VarID, FieldType, Loc);
416 }
417
418 /// Create the entity for a compound literal initializer.
421 TSI->getType());
422 Result.TypeInfo = TSI;
423 return Result;
424 }
425
426 /// Determine the kind of initialization.
427 EntityKind getKind() const { return Kind; }
428
429 /// Retrieve the parent of the entity being initialized, when
430 /// the initialization itself is occurring within the context of a
431 /// larger initialization.
432 const InitializedEntity *getParent() const { return Parent; }
433
434 /// Retrieve type being initialized.
435 QualType getType() const { return Type; }
436
437 /// Retrieve complete type-source information for the object being
438 /// constructed, if known.
440 if (Kind == EK_Temporary || Kind == EK_CompoundLiteralInit)
441 return TypeInfo;
442
443 return nullptr;
444 }
445
446 /// Retrieve the name of the entity being initialized.
447 DeclarationName getName() const;
448
449 /// Retrieve the variable, parameter, or field being
450 /// initialized.
451 ValueDecl *getDecl() const;
452
453 /// Retrieve the ObjectiveC method being initialized.
455
456 /// Determine whether this initialization allows the named return
457 /// value optimization, which also applies to thrown objects.
458 bool allowsNRVO() const;
459
460 bool isParameterKind() const {
461 return (getKind() == EK_Parameter ||
463 }
464
467 }
468
469 /// Determine whether this initialization consumes the
470 /// parameter.
471 bool isParameterConsumed() const {
472 assert(isParameterKind() && "Not a parameter");
473 return Parameter.getInt();
474 }
475
476 /// Retrieve the base specifier.
478 assert(getKind() == EK_Base && "Not a base specifier");
479 return Base.getPointer();
480 }
481
482 /// Return whether the base is an inherited virtual base.
484 assert(getKind() == EK_Base && "Not a base specifier");
485 return Base.getInt();
486 }
487
488 /// Determine whether this is an array new with an unknown bound.
490 return getKind() == EK_New && isa_and_nonnull<IncompleteArrayType>(
491 getType()->getAsArrayTypeUnsafe());
492 }
493
494 /// Is this the implicit initialization of a member of a class from
495 /// a defaulted constructor?
497 return getKind() == EK_Member && Variable.IsImplicitFieldInit;
498 }
499
500 /// Is this the default member initializer of a member (specified inside
501 /// the class definition)?
503 return getKind() == EK_Member && Variable.IsDefaultMemberInit;
504 }
505
506 /// Determine the location of the 'return' keyword when initializing
507 /// the result of a function call.
509 assert(getKind() == EK_Result && "No 'return' location!");
510 return LocAndNRVO.Location;
511 }
512
513 /// Determine the location of the 'throw' keyword when initializing
514 /// an exception object.
516 assert(getKind() == EK_Exception && "No 'throw' location!");
517 return LocAndNRVO.Location;
518 }
519
520 /// If this is an array, vector, or complex number element, get the
521 /// element's index.
522 unsigned getElementIndex() const {
523 assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement ||
525 return Index;
526 }
527
528 /// If this is already the initializer for an array or vector
529 /// element, sets the element index.
530 void setElementIndex(unsigned Index) {
531 assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement ||
533 this->Index = Index;
534 }
535
536 /// For a lambda capture, return the capture's name.
537 StringRef getCapturedVarName() const {
538 assert(getKind() == EK_LambdaCapture && "Not a lambda capture!");
539 return Capture.VarID ? Capture.VarID->getName() : "this";
540 }
541
542 /// Determine the location of the capture when initializing
543 /// field from a captured variable in a lambda.
545 assert(getKind() == EK_LambdaCapture && "Not a lambda capture!");
546 return Capture.Location;
547 }
548
551 }
552
553 unsigned allocateManglingNumber() const { return ++ManglingNumber; }
554
555 /// Dump a representation of the initialized entity to standard error,
556 /// for debugging purposes.
557 void dump() const;
558
559private:
560 unsigned dumpImpl(raw_ostream &OS) const;
561};
562
563/// Describes the kind of initialization being performed, along with
564/// location information for tokens related to the initialization (equal sign,
565/// parentheses).
567public:
568 /// The kind of initialization being performed.
569 enum InitKind {
570 /// Direct initialization
572
573 /// Direct list-initialization
575
576 /// Copy initialization
578
579 /// Default initialization
581
582 /// Value initialization
584 };
585
586private:
587 /// The context of the initialization.
588 enum InitContext {
589 /// Normal context
590 IC_Normal,
591
592 /// Normal context, but allows explicit conversion functionss
593 IC_ExplicitConvs,
594
595 /// Implicit context (value initialization)
596 IC_Implicit,
597
598 /// Static cast context
599 IC_StaticCast,
600
601 /// C-style cast context
602 IC_CStyleCast,
603
604 /// Functional cast context
605 IC_FunctionalCast
606 };
607
608 /// The kind of initialization being performed.
609 InitKind Kind : 8;
610
611 /// The context of the initialization.
612 InitContext Context : 8;
613
614 /// The source locations involved in the initialization.
615 SourceLocation Locations[3];
616
617 InitializationKind(InitKind Kind, InitContext Context, SourceLocation Loc1,
618 SourceLocation Loc2, SourceLocation Loc3)
619 : Kind(Kind), Context(Context) {
620 Locations[0] = Loc1;
621 Locations[1] = Loc2;
622 Locations[2] = Loc3;
623 }
624
625public:
626 /// Create a direct initialization.
628 SourceLocation LParenLoc,
629 SourceLocation RParenLoc) {
630 return InitializationKind(IK_Direct, IC_Normal,
631 InitLoc, LParenLoc, RParenLoc);
632 }
633
635 return InitializationKind(IK_DirectList, IC_Normal, InitLoc, InitLoc,
636 InitLoc);
637 }
638
640 SourceLocation LBraceLoc,
641 SourceLocation RBraceLoc) {
642 return InitializationKind(IK_DirectList, IC_Normal, InitLoc, LBraceLoc,
643 RBraceLoc);
644 }
645
646 /// Create a direct initialization due to a cast that isn't a C-style
647 /// or functional cast.
649 return InitializationKind(IK_Direct, IC_StaticCast, TypeRange.getBegin(),
650 TypeRange.getBegin(), TypeRange.getEnd());
651 }
652
653 /// Create a direct initialization for a C-style cast.
655 SourceRange TypeRange,
656 bool InitList) {
657 // C++ cast syntax doesn't permit init lists, but C compound literals are
658 // exactly that.
659 return InitializationKind(InitList ? IK_DirectList : IK_Direct,
660 IC_CStyleCast, StartLoc, TypeRange.getBegin(),
661 TypeRange.getEnd());
662 }
663
664 /// Create a direct initialization for a functional cast.
666 bool InitList) {
667 return InitializationKind(InitList ? IK_DirectList : IK_Direct,
668 IC_FunctionalCast, TypeRange.getBegin(),
669 TypeRange.getBegin(), TypeRange.getEnd());
670 }
671
672 /// Create a copy initialization.
674 SourceLocation EqualLoc,
675 bool AllowExplicitConvs = false) {
677 AllowExplicitConvs? IC_ExplicitConvs : IC_Normal,
678 InitLoc, EqualLoc, EqualLoc);
679 }
680
681 /// Create a default initialization.
683 return InitializationKind(IK_Default, IC_Normal, InitLoc, InitLoc, InitLoc);
684 }
685
686 /// Create a value initialization.
688 SourceLocation LParenLoc,
689 SourceLocation RParenLoc,
690 bool isImplicit = false) {
691 return InitializationKind(IK_Value, isImplicit ? IC_Implicit : IC_Normal,
692 InitLoc, LParenLoc, RParenLoc);
693 }
694
695 /// Create an initialization from an initializer (which, for direct
696 /// initialization from a parenthesized list, will be a ParenListExpr).
698 Expr *Init) {
699 if (!Init) return CreateDefault(Loc);
700 if (!DirectInit)
701 return CreateCopy(Loc, Init->getBeginLoc());
702 if (isa<InitListExpr>(Init))
703 return CreateDirectList(Loc, Init->getBeginLoc(), Init->getEndLoc());
704 return CreateDirect(Loc, Init->getBeginLoc(), Init->getEndLoc());
705 }
706
707 /// Determine the initialization kind.
709 return Kind;
710 }
711
712 /// Determine whether this initialization is an explicit cast.
713 bool isExplicitCast() const {
714 return Context >= IC_StaticCast;
715 }
716
717 /// Determine whether this initialization is a static cast.
718 bool isStaticCast() const { return Context == IC_StaticCast; }
719
720 /// Determine whether this initialization is a C-style cast.
722 return Context >= IC_CStyleCast;
723 }
724
725 /// Determine whether this is a C-style cast.
726 bool isCStyleCast() const {
727 return Context == IC_CStyleCast;
728 }
729
730 /// Determine whether this is a functional-style cast.
731 bool isFunctionalCast() const {
732 return Context == IC_FunctionalCast;
733 }
734
735 /// Determine whether this initialization is an implicit
736 /// value-initialization, e.g., as occurs during aggregate
737 /// initialization.
738 bool isImplicitValueInit() const { return Context == IC_Implicit; }
739
740 /// Retrieve the location at which initialization is occurring.
741 SourceLocation getLocation() const { return Locations[0]; }
742
743 /// Retrieve the source range that covers the initialization.
745 return SourceRange(Locations[0], Locations[2]);
746 }
747
748 /// Retrieve the location of the equal sign for copy initialization
749 /// (if present).
751 assert(Kind == IK_Copy && "Only copy initialization has an '='");
752 return Locations[1];
753 }
754
755 bool isCopyInit() const { return Kind == IK_Copy; }
756
757 /// Retrieve whether this initialization allows the use of explicit
758 /// constructors.
759 bool AllowExplicit() const { return !isCopyInit(); }
760
761 /// Retrieve whether this initialization allows the use of explicit
762 /// conversion functions when binding a reference. If the reference is the
763 /// first parameter in a copy or move constructor, such conversions are
764 /// permitted even though we are performing copy-initialization.
766 return !isCopyInit() || Context == IC_ExplicitConvs;
767 }
768
769 /// Determine whether this initialization has a source range containing the
770 /// locations of open and closing parentheses or braces.
771 bool hasParenOrBraceRange() const {
772 return Kind == IK_Direct || Kind == IK_Value || Kind == IK_DirectList;
773 }
774
775 /// Retrieve the source range containing the locations of the open
776 /// and closing parentheses or braces for value, direct, and direct list
777 /// initializations.
779 assert(hasParenOrBraceRange() && "Only direct, value, and direct-list "
780 "initialization have parentheses or "
781 "braces");
782 return SourceRange(Locations[1], Locations[2]);
783 }
784};
785
786/// Describes the sequence of initializations required to initialize
787/// a given object or reference with a set of arguments.
789public:
790 /// Describes the kind of initialization sequence computed.
792 /// A failed initialization sequence. The failure kind tells what
793 /// happened.
795
796 /// A dependent initialization, which could not be
797 /// type-checked due to the presence of dependent types or
798 /// dependently-typed expressions.
800
801 /// A normal sequence.
803 };
804
805 /// Describes the kind of a particular step in an initialization
806 /// sequence.
807 enum StepKind {
808 /// Resolve the address of an overloaded function to a specific
809 /// function declaration.
811
812 /// Perform a derived-to-base cast, producing an rvalue.
814
815 /// Perform a derived-to-base cast, producing an xvalue.
817
818 /// Perform a derived-to-base cast, producing an lvalue.
820
821 /// Reference binding to an lvalue.
823
824 /// Reference binding to a temporary.
826
827 /// An optional copy of a temporary object to another
828 /// temporary object, which is permitted (but not required) by
829 /// C++98/03 but not C++0x.
831
832 /// Direct-initialization from a reference-related object in the
833 /// final stage of class copy-initialization.
835
836 /// Perform a user-defined conversion, either via a conversion
837 /// function or via a constructor.
839
840 /// Perform a qualification conversion, producing a prvalue.
842
843 /// Perform a qualification conversion, producing an xvalue.
845
846 /// Perform a qualification conversion, producing an lvalue.
848
849 /// Perform a function reference conversion, see [dcl.init.ref]p4.
851
852 /// Perform a conversion adding _Atomic to a type.
854
855 /// Perform an implicit conversion sequence.
857
858 /// Perform an implicit conversion sequence without narrowing.
860
861 /// Perform list-initialization without a constructor.
863
864 /// Unwrap the single-element initializer list for a reference.
866
867 /// Rewrap the single-element initializer list for a reference.
869
870 /// Perform initialization via a constructor.
872
873 /// Perform initialization via a constructor, taking arguments from
874 /// a single InitListExpr.
876
877 /// Zero-initialize the object
879
880 /// C assignment
882
883 /// Initialization by string
885
886 /// An initialization that "converts" an Objective-C object
887 /// (not a point to an object) to another Objective-C object type.
889
890 /// Array indexing for initialization by elementwise copy.
892
893 /// Array initialization by elementwise copy.
895
896 /// Array initialization (from an array rvalue).
898
899 /// Array initialization (from an array rvalue) as a GNU extension.
901
902 /// Array initialization from a parenthesized initializer list.
903 /// This is a GNU C++ extension.
905
906 /// Pass an object by indirect copy-and-restore.
908
909 /// Pass an object by indirect restore.
911
912 /// Produce an Objective-C object pointer.
914
915 /// Construct a std::initializer_list from an initializer list.
917
918 /// Perform initialization via a constructor taking a single
919 /// std::initializer_list argument.
921
922 /// Initialize an OpenCL sampler from an integer.
924
925 /// Initialize an opaque OpenCL type (event_t, queue_t, etc.) with zero
927
928 /// Initialize an aggreagate with parenthesized list of values.
929 /// This is a C++20 feature.
931 };
932
933 /// A single step in the initialization sequence.
934 class Step {
935 public:
936 /// The kind of conversion or initialization step we are taking.
938
939 // The type that results from this initialization.
941
942 struct F {
946 };
947
948 union {
949 /// When Kind == SK_ResolvedOverloadedFunction or Kind ==
950 /// SK_UserConversion, the function that the expression should be
951 /// resolved to or the conversion function to call, respectively.
952 /// When Kind == SK_ConstructorInitialization or SK_ListConstruction,
953 /// the constructor to be called.
954 ///
955 /// Always a FunctionDecl, plus a Boolean flag telling if it was
956 /// selected from an overloaded set having size greater than 1.
957 /// For conversion decls, the naming class is the source type.
958 /// For construct decls, the naming class is the target type.
959 struct F Function;
960
961 /// When Kind = SK_ConversionSequence, the implicit conversion
962 /// sequence.
964
965 /// When Kind = SK_RewrapInitList, the syntactic form of the
966 /// wrapping list.
968 };
969
970 void Destroy();
971 };
972
973private:
974 /// The kind of initialization sequence computed.
976
977 /// Steps taken by this initialization.
979
980public:
981 /// Describes why initialization failed.
983 /// Too many initializers provided for a reference.
985
986 /// Reference initialized from a parenthesized initializer list.
988
989 /// Array must be initialized with an initializer list.
991
992 /// Array must be initialized with an initializer list or a
993 /// string literal.
995
996 /// Array must be initialized with an initializer list or a
997 /// wide string literal.
999
1000 /// Initializing a wide char array with narrow string literal.
1002
1003 /// Initializing char array with wide string literal.
1005
1006 /// Initializing wide char array with incompatible wide string
1007 /// literal.
1009
1010 /// Initializing char8_t array with plain string literal.
1012
1013 /// Initializing char array with UTF-8 string literal.
1015
1016 /// Array type mismatch.
1018
1019 /// Non-constant array initializer
1021
1022 /// Cannot resolve the address of an overloaded function.
1024
1025 /// Overloading due to reference initialization failed.
1027
1028 /// Non-const lvalue reference binding to a temporary.
1030
1031 /// Non-const lvalue reference binding to a bit-field.
1033
1034 /// Non-const lvalue reference binding to a vector element.
1036
1037 /// Non-const lvalue reference binding to a matrix element.
1039
1040 /// Non-const lvalue reference binding to an lvalue of unrelated
1041 /// type.
1043
1044 /// Rvalue reference binding to an lvalue.
1046
1047 /// Reference binding drops qualifiers.
1049
1050 /// Reference with mismatching address space binding to temporary.
1052
1053 /// Reference binding failed.
1055
1056 /// Implicit conversion failed.
1058
1059 /// Implicit conversion failed.
1061
1062 /// Too many initializers for scalar
1064
1065 /// Scalar initialized from a parenthesized initializer list.
1067
1068 /// Reference initialization from an initializer list
1070
1071 /// Initialization of some unused destination type with an
1072 /// initializer list.
1074
1075 /// Overloading for a user-defined conversion failed.
1077
1078 /// Overloading for initialization by constructor failed.
1080
1081 /// Overloading for list-initialization by constructor failed.
1083
1084 /// Default-initialization of a 'const' object.
1086
1087 /// Initialization of an incomplete type.
1089
1090 /// Variable-length array must not have an initializer.
1092
1093 /// List initialization failed at some point.
1095
1096 /// Initializer has a placeholder type which cannot be
1097 /// resolved by initialization.
1099
1100 /// Trying to take the address of a function that doesn't support
1101 /// having its address taken.
1103
1104 /// List-copy-initialization chose an explicit constructor.
1106
1107 /// Parenthesized list initialization failed at some point.
1108 /// This is a C++20 feature.
1110 };
1111
1112private:
1113 /// The reason why initialization failed.
1114 FailureKind Failure;
1115
1116 /// The failed result of overload resolution.
1117 OverloadingResult FailedOverloadResult;
1118
1119 /// The candidate set created when initialization failed.
1120 OverloadCandidateSet FailedCandidateSet;
1121
1122 /// The incomplete type that caused a failure.
1123 QualType FailedIncompleteType;
1124
1125 /// The fixit that needs to be applied to make this initialization
1126 /// succeed.
1127 std::string ZeroInitializationFixit;
1128 SourceLocation ZeroInitializationFixitLoc;
1129
1130public:
1131 /// Call for initializations are invalid but that would be valid
1132 /// zero initialzations if Fixit was applied.
1133 void SetZeroInitializationFixit(const std::string& Fixit, SourceLocation L) {
1134 ZeroInitializationFixit = Fixit;
1135 ZeroInitializationFixitLoc = L;
1136 }
1137
1138private:
1139 /// Prints a follow-up note that highlights the location of
1140 /// the initialized entity, if it's remote.
1141 void PrintInitLocationNote(Sema &S, const InitializedEntity &Entity);
1142
1143public:
1144 /// Try to perform initialization of the given entity, creating a
1145 /// record of the steps required to perform the initialization.
1146 ///
1147 /// The generated initialization sequence will either contain enough
1148 /// information to diagnose
1149 ///
1150 /// \param S the semantic analysis object.
1151 ///
1152 /// \param Entity the entity being initialized.
1153 ///
1154 /// \param Kind the kind of initialization being performed.
1155 ///
1156 /// \param Args the argument(s) provided for initialization.
1157 ///
1158 /// \param TopLevelOfInitList true if we are initializing from an expression
1159 /// at the top level inside an initializer list. This disallows
1160 /// narrowing conversions in C++11 onwards.
1161 /// \param TreatUnavailableAsInvalid true if we want to treat unavailable
1162 /// as invalid.
1164 const InitializedEntity &Entity,
1165 const InitializationKind &Kind,
1166 MultiExprArg Args,
1167 bool TopLevelOfInitList = false,
1168 bool TreatUnavailableAsInvalid = true);
1169 void InitializeFrom(Sema &S, const InitializedEntity &Entity,
1170 const InitializationKind &Kind, MultiExprArg Args,
1171 bool TopLevelOfInitList, bool TreatUnavailableAsInvalid);
1172
1174
1175 /// Perform the actual initialization of the given entity based on
1176 /// the computed initialization sequence.
1177 ///
1178 /// \param S the semantic analysis object.
1179 ///
1180 /// \param Entity the entity being initialized.
1181 ///
1182 /// \param Kind the kind of initialization being performed.
1183 ///
1184 /// \param Args the argument(s) provided for initialization, ownership of
1185 /// which is transferred into the routine.
1186 ///
1187 /// \param ResultType if non-NULL, will be set to the type of the
1188 /// initialized object, which is the type of the declaration in most
1189 /// cases. However, when the initialized object is a variable of
1190 /// incomplete array type and the initializer is an initializer
1191 /// list, this type will be set to the completed array type.
1192 ///
1193 /// \returns an expression that performs the actual object initialization, if
1194 /// the initialization is well-formed. Otherwise, emits diagnostics
1195 /// and returns an invalid expression.
1197 const InitializedEntity &Entity,
1198 const InitializationKind &Kind,
1199 MultiExprArg Args,
1200 QualType *ResultType = nullptr);
1201
1202 /// Diagnose an potentially-invalid initialization sequence.
1203 ///
1204 /// \returns true if the initialization sequence was ill-formed,
1205 /// false otherwise.
1206 bool Diagnose(Sema &S,
1207 const InitializedEntity &Entity,
1208 const InitializationKind &Kind,
1209 ArrayRef<Expr *> Args);
1210
1211 /// Determine the kind of initialization sequence computed.
1212 enum SequenceKind getKind() const { return SequenceKind; }
1213
1214 /// Set the kind of sequence computed.
1216
1217 /// Determine whether the initialization sequence is valid.
1218 explicit operator bool() const { return !Failed(); }
1219
1220 /// Determine whether the initialization sequence is invalid.
1221 bool Failed() const { return SequenceKind == FailedSequence; }
1222
1224
1225 step_iterator step_begin() const { return Steps.begin(); }
1226 step_iterator step_end() const { return Steps.end(); }
1227
1228 using step_range = llvm::iterator_range<step_iterator>;
1229
1230 step_range steps() const { return {step_begin(), step_end()}; }
1231
1232 /// Determine whether this initialization is a direct reference
1233 /// binding (C++ [dcl.init.ref]).
1234 bool isDirectReferenceBinding() const;
1235
1236 /// Determine whether this initialization failed due to an ambiguity.
1237 bool isAmbiguous() const;
1238
1239 /// Determine whether this initialization is direct call to a
1240 /// constructor.
1241 bool isConstructorInitialization() const;
1242
1243 /// Add a new step in the initialization that resolves the address
1244 /// of an overloaded function to a specific function declaration.
1245 ///
1246 /// \param Function the function to which the overloaded function reference
1247 /// resolves.
1249 DeclAccessPair Found,
1250 bool HadMultipleCandidates);
1251
1252 /// Add a new step in the initialization that performs a derived-to-
1253 /// base cast.
1254 ///
1255 /// \param BaseType the base type to which we will be casting.
1256 ///
1257 /// \param Category Indicates whether the result will be treated as an
1258 /// rvalue, an xvalue, or an lvalue.
1259 void AddDerivedToBaseCastStep(QualType BaseType,
1261
1262 /// Add a new step binding a reference to an object.
1263 ///
1264 /// \param BindingTemporary True if we are binding a reference to a temporary
1265 /// object (thereby extending its lifetime); false if we are binding to an
1266 /// lvalue or an lvalue treated as an rvalue.
1267 void AddReferenceBindingStep(QualType T, bool BindingTemporary);
1268
1269 /// Add a new step that makes an extraneous copy of the input
1270 /// to a temporary of the same class type.
1271 ///
1272 /// This extraneous copy only occurs during reference binding in
1273 /// C++98/03, where we are permitted (but not required) to introduce
1274 /// an extra copy. At a bare minimum, we must check that we could
1275 /// call the copy constructor, and produce a diagnostic if the copy
1276 /// constructor is inaccessible or no copy constructor matches.
1277 //
1278 /// \param T The type of the temporary being created.
1280
1281 /// Add a new step that makes a copy of the input to an object of
1282 /// the given type, as the final step in class copy-initialization.
1283 void AddFinalCopy(QualType T);
1284
1285 /// Add a new step invoking a conversion function, which is either
1286 /// a constructor or a conversion function.
1287 void AddUserConversionStep(FunctionDecl *Function,
1288 DeclAccessPair FoundDecl,
1289 QualType T,
1290 bool HadMultipleCandidates);
1291
1292 /// Add a new step that performs a qualification conversion to the
1293 /// given type.
1296
1297 /// Add a new step that performs a function reference conversion to the
1298 /// given type.
1300
1301 /// Add a new step that performs conversion from non-atomic to atomic
1302 /// type.
1304
1305 /// Add a new step that applies an implicit conversion sequence.
1307 QualType T, bool TopLevelOfInitList = false);
1308
1309 /// Add a list-initialization step.
1311
1312 /// Add a constructor-initialization step.
1313 ///
1314 /// \param FromInitList The constructor call is syntactically an initializer
1315 /// list.
1316 /// \param AsInitList The constructor is called as an init list constructor.
1318 CXXConstructorDecl *Constructor,
1319 QualType T,
1320 bool HadMultipleCandidates,
1321 bool FromInitList, bool AsInitList);
1322
1323 /// Add a zero-initialization step.
1325
1326 /// Add a C assignment step.
1327 //
1328 // FIXME: It isn't clear whether this should ever be needed;
1329 // ideally, we would handle everything needed in C in the common
1330 // path. However, that isn't the case yet.
1332
1333 /// Add a string init step.
1335
1336 /// Add an Objective-C object conversion step, which is
1337 /// always a no-op.
1339
1340 /// Add an array initialization loop step.
1341 void AddArrayInitLoopStep(QualType T, QualType EltTy);
1342
1343 /// Add an array initialization step.
1344 void AddArrayInitStep(QualType T, bool IsGNUExtension);
1345
1346 /// Add a parenthesized array initialization step.
1348
1349 /// Add a step to pass an object by indirect copy-restore.
1350 void AddPassByIndirectCopyRestoreStep(QualType T, bool shouldCopy);
1351
1352 /// Add a step to "produce" an Objective-C object (by
1353 /// retaining it).
1355
1356 /// Add a step to construct a std::initializer_list object from an
1357 /// initializer list.
1359
1360 /// Add a step to initialize an OpenCL sampler from an integer
1361 /// constant.
1363
1364 /// Add a step to initialzie an OpenCL opaque type (event_t, queue_t, etc.)
1365 /// from a zero constant.
1367
1369
1370 /// Add steps to unwrap a initializer list for a reference around a
1371 /// single element and rewrap it at the end.
1372 void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic);
1373
1374 /// Note that this initialization sequence failed.
1375 void SetFailed(FailureKind Failure) {
1377 this->Failure = Failure;
1378 assert((Failure != FK_Incomplete || !FailedIncompleteType.isNull()) &&
1379 "Incomplete type failure requires a type!");
1380 }
1381
1382 /// Note that this initialization sequence failed due to failed
1383 /// overload resolution.
1385
1386 /// Retrieve a reference to the candidate set when overload
1387 /// resolution fails.
1389 return FailedCandidateSet;
1390 }
1391
1392 /// Get the overloading result, for when the initialization
1393 /// sequence failed due to a bad overload.
1395 return FailedOverloadResult;
1396 }
1397
1398 /// Note that this initialization sequence failed due to an
1399 /// incomplete type.
1400 void setIncompleteTypeFailure(QualType IncompleteType) {
1401 FailedIncompleteType = IncompleteType;
1403 }
1404
1405 /// Determine why initialization failed.
1407 assert(Failed() && "Not an initialization failure!");
1408 return Failure;
1409 }
1410
1411 /// Dump a representation of this initialization sequence to
1412 /// the given stream, for debugging purposes.
1413 void dump(raw_ostream &OS) const;
1414
1415 /// Dump a representation of this initialization sequence to
1416 /// standard error, for debugging purposes.
1417 void dump() const;
1418};
1419
1420} // namespace clang
1421
1422#endif // LLVM_CLANG_SEMA_INITIALIZATION_H
Defines the clang::ASTContext interface.
NodeId Parent
Definition: ASTDiff.cpp:191
MatchType Type
int Category
Definition: Format.cpp:2775
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
Defines the clang::SourceLocation class and associated facilities.
Defines various enumerations that describe declaration and type specifiers.
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2451
A POD class for pairing a NamedDecl* with an access specifier.
bool hasAttr() const
Definition: DeclBase.h:560
The name of a declaration.
This represents one expression.
Definition: Expr.h:110
Represents a member of a struct/union/class.
Definition: Decl.h:2943
Represents a function declaration or definition.
Definition: Decl.h:1919
One of these records is kept for each identifier that is lexed.
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Definition: Overload.h:517
Represents a field injected from an anonymous union/struct into the parent scope.
Definition: Decl.h:3198
Describes an C or C++ initializer list.
Definition: Expr.h:4798
Describes the kind of initialization being performed, along with location information for tokens rela...
SourceLocation getLocation() const
Retrieve the location at which initialization is occurring.
static InitializationKind CreateCast(SourceRange TypeRange)
Create a direct initialization due to a cast that isn't a C-style or functional cast.
InitKind
The kind of initialization being performed.
@ IK_DirectList
Direct list-initialization.
@ IK_Value
Value initialization.
@ IK_Direct
Direct initialization.
@ IK_Copy
Copy initialization.
@ IK_Default
Default initialization.
SourceLocation getEqualLoc() const
Retrieve the location of the equal sign for copy initialization (if present).
bool isCStyleOrFunctionalCast() const
Determine whether this initialization is a C-style cast.
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
bool hasParenOrBraceRange() const
Determine whether this initialization has a source range containing the locations of open and closing...
bool isExplicitCast() const
Determine whether this initialization is an explicit cast.
bool isFunctionalCast() const
Determine whether this is a functional-style cast.
InitKind getKind() const
Determine the initialization kind.
bool AllowExplicit() const
Retrieve whether this initialization allows the use of explicit constructors.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
bool isImplicitValueInit() const
Determine whether this initialization is an implicit value-initialization, e.g., as occurs during agg...
bool isCStyleCast() const
Determine whether this is a C-style cast.
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static InitializationKind CreateDirectList(SourceLocation InitLoc)
SourceRange getParenOrBraceRange() const
Retrieve the source range containing the locations of the open and closing parentheses or braces for ...
bool allowExplicitConversionFunctionsInRefBinding() const
Retrieve whether this initialization allows the use of explicit conversion functions when binding a r...
static InitializationKind CreateDirectList(SourceLocation InitLoc, SourceLocation LBraceLoc, SourceLocation RBraceLoc)
bool isStaticCast() const
Determine whether this initialization is a static cast.
static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, bool isImplicit=false)
Create a value initialization.
SourceRange getRange() const
Retrieve the source range that covers the initialization.
static InitializationKind CreateFunctionalCast(SourceRange TypeRange, bool InitList)
Create a direct initialization for a functional cast.
static InitializationKind CreateCStyleCast(SourceLocation StartLoc, SourceRange TypeRange, bool InitList)
Create a direct initialization for a C-style cast.
A single step in the initialization sequence.
StepKind Kind
The kind of conversion or initialization step we are taking.
InitListExpr * WrappingSyntacticList
When Kind = SK_RewrapInitList, the syntactic form of the wrapping list.
ImplicitConversionSequence * ICS
When Kind = SK_ConversionSequence, the implicit conversion sequence.
struct F Function
When Kind == SK_ResolvedOverloadedFunction or Kind == SK_UserConversion, the function that the expres...
Describes the sequence of initializations required to initialize a given object or reference with a s...
step_iterator step_begin() const
void AddListInitializationStep(QualType T)
Add a list-initialization step.
Definition: SemaInit.cpp:3718
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:8307
void AddStringInitStep(QualType T)
Add a string init step.
Definition: SemaInit.cpp:3753
void AddStdInitializerListConstructionStep(QualType T)
Add a step to construct a std::initializer_list object from an initializer list.
Definition: SemaInit.cpp:3808
void AddConstructorInitializationStep(DeclAccessPair FoundDecl, CXXConstructorDecl *Constructor, QualType T, bool HadMultipleCandidates, bool FromInitList, bool AsInitList)
Add a constructor-initialization step.
Definition: SemaInit.cpp:3725
StepKind
Describes the kind of a particular step in an initialization sequence.
@ SK_StdInitializerListConstructorCall
Perform initialization via a constructor taking a single std::initializer_list argument.
@ SK_AtomicConversion
Perform a conversion adding _Atomic to a type.
@ SK_ObjCObjectConversion
An initialization that "converts" an Objective-C object (not a point to an object) to another Objecti...
@ SK_GNUArrayInit
Array initialization (from an array rvalue) as a GNU extension.
@ SK_CastDerivedToBaseLValue
Perform a derived-to-base cast, producing an lvalue.
@ SK_ProduceObjCObject
Produce an Objective-C object pointer.
@ SK_FunctionReferenceConversion
Perform a function reference conversion, see [dcl.init.ref]p4.
@ SK_BindReference
Reference binding to an lvalue.
@ SK_ArrayLoopInit
Array initialization by elementwise copy.
@ SK_ConstructorInitialization
Perform initialization via a constructor.
@ SK_OCLSamplerInit
Initialize an OpenCL sampler from an integer.
@ SK_StringInit
Initialization by string.
@ SK_ZeroInitialization
Zero-initialize the object.
@ SK_CastDerivedToBaseXValue
Perform a derived-to-base cast, producing an xvalue.
@ SK_QualificationConversionXValue
Perform a qualification conversion, producing an xvalue.
@ SK_UserConversion
Perform a user-defined conversion, either via a conversion function or via a constructor.
@ SK_CastDerivedToBasePRValue
Perform a derived-to-base cast, producing an rvalue.
@ SK_BindReferenceToTemporary
Reference binding to a temporary.
@ SK_PassByIndirectRestore
Pass an object by indirect restore.
@ SK_ParenthesizedArrayInit
Array initialization from a parenthesized initializer list.
@ SK_ParenthesizedListInit
Initialize an aggreagate with parenthesized list of values.
@ SK_ArrayInit
Array initialization (from an array rvalue).
@ SK_ExtraneousCopyToTemporary
An optional copy of a temporary object to another temporary object, which is permitted (but not requi...
@ SK_ArrayLoopIndex
Array indexing for initialization by elementwise copy.
@ SK_ConversionSequenceNoNarrowing
Perform an implicit conversion sequence without narrowing.
@ SK_RewrapInitList
Rewrap the single-element initializer list for a reference.
@ SK_ConstructorInitializationFromList
Perform initialization via a constructor, taking arguments from a single InitListExpr.
@ SK_PassByIndirectCopyRestore
Pass an object by indirect copy-and-restore.
@ SK_ResolveAddressOfOverloadedFunction
Resolve the address of an overloaded function to a specific function declaration.
@ SK_UnwrapInitList
Unwrap the single-element initializer list for a reference.
@ SK_FinalCopy
Direct-initialization from a reference-related object in the final stage of class copy-initialization...
@ SK_QualificationConversionLValue
Perform a qualification conversion, producing an lvalue.
@ SK_StdInitializerList
Construct a std::initializer_list from an initializer list.
@ SK_QualificationConversionPRValue
Perform a qualification conversion, producing a prvalue.
@ SK_ConversionSequence
Perform an implicit conversion sequence.
@ SK_ListInitialization
Perform list-initialization without a constructor.
@ SK_OCLZeroOpaqueType
Initialize an opaque OpenCL type (event_t, queue_t, etc.) with zero.
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:3661
void SetZeroInitializationFixit(const std::string &Fixit, SourceLocation L)
Call for initializations are invalid but that would be valid zero initialzations if Fixit was applied...
llvm::iterator_range< step_iterator > step_range
void AddQualificationConversionStep(QualType Ty, ExprValueKind Category)
Add a new step that performs a qualification conversion to the given type.
Definition: SemaInit.cpp:3674
void AddFunctionReferenceConversionStep(QualType Ty)
Add a new step that performs a function reference conversion to the given type.
Definition: SemaInit.cpp:3693
void AddDerivedToBaseCastStep(QualType BaseType, ExprValueKind Category)
Add a new step in the initialization that performs a derived-to- base cast.
Definition: SemaInit.cpp:3624
FailureKind getFailureKind() const
Determine why initialization failed.
void InitializeFrom(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, bool TopLevelOfInitList, bool TreatUnavailableAsInvalid)
Definition: SemaInit.cpp:5944
void AddParenthesizedListInitStep(QualType T)
Definition: SemaInit.cpp:3829
void SetFailed(FailureKind Failure)
Note that this initialization sequence failed.
bool isAmbiguous() const
Determine whether this initialization failed due to an ambiguity.
Definition: SemaInit.cpp:3553
void AddOCLZeroOpaqueTypeStep(QualType T)
Add a step to initialzie an OpenCL opaque type (event_t, queue_t, etc.) from a zero constant.
Definition: SemaInit.cpp:3822
void AddFinalCopy(QualType T)
Add a new step that makes a copy of the input to an object of the given type, as the final step in cl...
Definition: SemaInit.cpp:3646
OverloadingResult getFailedOverloadResult() const
Get the overloading result, for when the initialization sequence failed due to a bad overload.
void setSequenceKind(enum SequenceKind SK)
Set the kind of sequence computed.
void AddObjCObjectConversionStep(QualType T)
Add an Objective-C object conversion step, which is always a no-op.
Definition: SemaInit.cpp:3760
void SetOverloadFailure(FailureKind Failure, OverloadingResult Result)
Note that this initialization sequence failed due to failed overload resolution.
Definition: SemaInit.cpp:3851
step_iterator step_end() const
void AddParenthesizedArrayInitStep(QualType T)
Add a parenthesized array initialization step.
Definition: SemaInit.cpp:3785
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:3653
void setIncompleteTypeFailure(QualType IncompleteType)
Note that this initialization sequence failed due to an incomplete type.
void AddOCLSamplerInitStep(QualType T)
Add a step to initialize an OpenCL sampler from an integer constant.
Definition: SemaInit.cpp:3815
void AddCAssignmentStep(QualType T)
Add a C assignment step.
Definition: SemaInit.cpp:3746
void AddPassByIndirectCopyRestoreStep(QualType T, bool shouldCopy)
Add a step to pass an object by indirect copy-restore.
Definition: SemaInit.cpp:3792
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:3836
bool Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef< Expr * > Args)
Diagnose an potentially-invalid initialization sequence.
Definition: SemaInit.cpp:9317
bool Failed() const
Determine whether the initialization sequence is invalid.
void AddAtomicConversionStep(QualType Ty)
Add a new step that performs conversion from non-atomic to atomic type.
Definition: SemaInit.cpp:3700
void dump() const
Dump a representation of this initialization sequence to standard error, for debugging purposes.
Definition: SemaInit.cpp:10143
void AddConversionSequenceStep(const ImplicitConversionSequence &ICS, QualType T, bool TopLevelOfInitList=false)
Add a new step that applies an implicit conversion sequence.
Definition: SemaInit.cpp:3707
void AddZeroInitializationStep(QualType T)
Add a zero-initialization step.
Definition: SemaInit.cpp:3739
void AddProduceObjCObjectStep(QualType T)
Add a step to "produce" an Objective-C object (by retaining it).
Definition: SemaInit.cpp:3801
enum SequenceKind getKind() const
Determine the kind of initialization sequence computed.
SequenceKind
Describes the kind of initialization sequence computed.
@ NormalSequence
A normal sequence.
@ FailedSequence
A failed initialization sequence.
@ DependentSequence
A dependent initialization, which could not be type-checked due to the presence of dependent types or...
void AddReferenceBindingStep(QualType T, bool BindingTemporary)
Add a new step binding a reference to an object.
Definition: SemaInit.cpp:3638
FailureKind
Describes why initialization failed.
@ FK_UserConversionOverloadFailed
Overloading for a user-defined conversion failed.
@ FK_NarrowStringIntoWideCharArray
Initializing a wide char array with narrow string literal.
@ FK_ArrayTypeMismatch
Array type mismatch.
@ FK_ParenthesizedListInitForReference
Reference initialized from a parenthesized initializer list.
@ FK_NonConstLValueReferenceBindingToVectorElement
Non-const lvalue reference binding to a vector element.
@ FK_ReferenceInitDropsQualifiers
Reference binding drops qualifiers.
@ FK_InitListBadDestinationType
Initialization of some unused destination type with an initializer list.
@ FK_ConversionFromPropertyFailed
Implicit conversion failed.
@ FK_NonConstLValueReferenceBindingToUnrelated
Non-const lvalue reference binding to an lvalue of unrelated type.
@ FK_ListConstructorOverloadFailed
Overloading for list-initialization by constructor failed.
@ FK_ReferenceInitFailed
Reference binding failed.
@ FK_ArrayNeedsInitList
Array must be initialized with an initializer list.
@ FK_PlainStringIntoUTF8Char
Initializing char8_t array with plain string literal.
@ FK_NonConstantArrayInit
Non-constant array initializer.
@ FK_NonConstLValueReferenceBindingToTemporary
Non-const lvalue reference binding to a temporary.
@ FK_ConversionFailed
Implicit conversion failed.
@ FK_ArrayNeedsInitListOrStringLiteral
Array must be initialized with an initializer list or a string literal.
@ FK_ParenthesizedListInitForScalar
Scalar initialized from a parenthesized initializer list.
@ FK_PlaceholderType
Initializer has a placeholder type which cannot be resolved by initialization.
@ FK_IncompatWideStringIntoWideChar
Initializing wide char array with incompatible wide string literal.
@ FK_NonConstLValueReferenceBindingToMatrixElement
Non-const lvalue reference binding to a matrix element.
@ FK_TooManyInitsForReference
Too many initializers provided for a reference.
@ FK_NonConstLValueReferenceBindingToBitfield
Non-const lvalue reference binding to a bit-field.
@ FK_ReferenceAddrspaceMismatchTemporary
Reference with mismatching address space binding to temporary.
@ FK_ListInitializationFailed
List initialization failed at some point.
@ FK_TooManyInitsForScalar
Too many initializers for scalar.
@ FK_AddressOfOverloadFailed
Cannot resolve the address of an overloaded function.
@ FK_VariableLengthArrayHasInitializer
Variable-length array must not have an initializer.
@ FK_ArrayNeedsInitListOrWideStringLiteral
Array must be initialized with an initializer list or a wide string literal.
@ FK_RValueReferenceBindingToLValue
Rvalue reference binding to an lvalue.
@ FK_Incomplete
Initialization of an incomplete type.
@ FK_WideStringIntoCharArray
Initializing char array with wide string literal.
@ FK_ExplicitConstructor
List-copy-initialization chose an explicit constructor.
@ FK_ReferenceInitOverloadFailed
Overloading due to reference initialization failed.
@ FK_ConstructorOverloadFailed
Overloading for initialization by constructor failed.
@ FK_ReferenceBindingToInitList
Reference initialization from an initializer list.
@ FK_DefaultInitOfConst
Default-initialization of a 'const' object.
@ FK_ParenthesizedListInitFailed
Parenthesized list initialization failed at some point.
@ FK_AddressOfUnaddressableFunction
Trying to take the address of a function that doesn't support having its address taken.
@ FK_UTF8StringIntoPlainChar
Initializing char array with UTF-8 string literal.
bool isDirectReferenceBinding() const
Determine whether this initialization is a direct reference binding (C++ [dcl.init....
Definition: SemaInit.cpp:3542
void AddArrayInitLoopStep(QualType T, QualType EltTy)
Add an array initialization loop step.
Definition: SemaInit.cpp:3774
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:3612
void AddArrayInitStep(QualType T, bool IsGNUExtension)
Add an array initialization step.
Definition: SemaInit.cpp:3767
bool isConstructorInitialization() const
Determine whether this initialization is direct call to a constructor.
Definition: SemaInit.cpp:3606
SmallVectorImpl< Step >::const_iterator step_iterator
OverloadCandidateSet & getFailedCandidateSet()
Retrieve a reference to the candidate set when overload resolution fails.
Describes an entity that is being initialized.
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:3329
static InitializedEntity InitializeResult(SourceLocation ReturnLoc, QualType Type)
Create the initialization entity for the result of a function.
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
VD Variable
When Kind == EK_Variable, EK_Member, EK_Binding, or EK_TemplateParameter, the variable,...
static InitializedEntity InitializeRelatedResult(ObjCMethodDecl *MD, QualType Type)
Create the initialization entity for a related result.
EntityKind getKind() const
Determine the kind of initialization.
DeclarationName getName() const
Retrieve the name of the entity being initialized.
Definition: SemaInit.cpp:3341
static InitializedEntity InitializeException(SourceLocation ThrowLoc, QualType Type)
Create the initialization entity for an exception object.
unsigned allocateManglingNumber() const
QualType getType() const
Retrieve type being initialized.
static InitializedEntity InitializeTemporary(ASTContext &Context, TypeSourceInfo *TypeInfo)
Create the initialization entity for a temporary.
ValueDecl * getDecl() const
Retrieve the variable, parameter, or field being initialized.
Definition: SemaInit.cpp:3378
static InitializedEntity InitializeParameter(ASTContext &Context, QualType Type, bool Consumed)
Create the initialization entity for a parameter that is only known by its type.
static InitializedEntity InitializeStmtExprResult(SourceLocation ReturnLoc, QualType Type)
bool isImplicitMemberInitializer() const
Is this the implicit initialization of a member of a class from a defaulted constructor?
const InitializedEntity * getParent() const
Retrieve the parent of the entity being initialized, when the initialization itself is occurring with...
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
bool isParameterConsumed() const
Determine whether this initialization consumes the parameter.
static InitializedEntity InitializeBinding(VarDecl *Binding)
Create the initialization entity for a structured binding.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm, QualType Type)
Create the initialization entity for a parameter, but use another type.
TypeSourceInfo * TypeInfo
When Kind == EK_Temporary or EK_CompoundLiteralInit, the type source information for the temporary.
static InitializedEntity InitializeMemberFromDefaultMemberInitializer(FieldDecl *Member)
Create the initialization entity for a default member initializer.
static InitializedEntity InitializeElement(ASTContext &Context, unsigned Index, const InitializedEntity &Parent)
Create the initialization entity for an array element.
unsigned getElementIndex() const
If this is an array, vector, or complex number element, get the element's index.
bool isInheritedVirtualBase() const
Return whether the base is an inherited virtual base.
static InitializedEntity InitializeLambdaToBlock(SourceLocation BlockVarLoc, QualType Type)
void setElementIndex(unsigned Index)
If this is already the initializer for an array or vector element, sets the element index.
SourceLocation getCaptureLoc() const
Determine the location of the capture when initializing field from a captured variable in a lambda.
static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc, QualType Type)
bool isParamOrTemplateParamKind() const
static InitializedEntity InitializeNew(SourceLocation NewLoc, QualType Type)
Create the initialization entity for an object allocated via new.
llvm::PointerIntPair< const CXXBaseSpecifier *, 1 > Base
When Kind == EK_Base, the base specifier that provides the base class.
static InitializedEntity InitializeTemporary(TypeSourceInfo *TypeInfo, QualType Type)
Create the initialization entity for a temporary.
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
bool allowsNRVO() const
Determine whether this initialization allows the named return value optimization, which also applies ...
Definition: SemaInit.cpp:3411
void dump() const
Dump a representation of the initialized entity to standard error, for debugging purposes.
Definition: SemaInit.cpp:3488
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static InitializedEntity InitializeLambdaCapture(IdentifierInfo *VarID, QualType FieldType, SourceLocation Loc)
Create the initialization entity for a lambda capture.
EntityKind
Specifies the kind of entity being initialized.
@ EK_Variable
The entity being initialized is a variable.
@ EK_Temporary
The entity being initialized is a temporary object.
@ EK_Binding
The entity being initialized is a structured binding of a decomposition declaration.
@ EK_BlockElement
The entity being initialized is a field of block descriptor for the copied-in c++ object.
@ EK_Parameter_CF_Audited
The entity being initialized is a function parameter; function is member of group of audited CF APIs.
@ EK_LambdaToBlockConversionBlockElement
The entity being initialized is a field of block descriptor for the copied-in lambda object that's us...
@ EK_Member
The entity being initialized is a non-static data member subobject.
@ EK_Base
The entity being initialized is a base member subobject.
@ EK_Result
The entity being initialized is the result of a function call.
@ EK_TemplateParameter
The entity being initialized is a non-type template parameter.
@ EK_StmtExprResult
The entity being initialized is the result of a statement expression.
@ EK_VectorElement
The entity being initialized is an element of a vector.
@ EK_New
The entity being initialized is an object (or array of objects) allocated via new.
@ EK_CompoundLiteralInit
The entity being initialized is the initializer for a compound literal.
@ EK_Parameter
The entity being initialized is a function parameter.
@ EK_Delegating
The initialization is being done by a delegating constructor.
@ EK_ComplexElement
The entity being initialized is the real or imaginary part of a complex number.
@ EK_ArrayElement
The entity being initialized is an element of an array.
@ EK_LambdaCapture
The entity being initialized is the field that captures a variable in a lambda.
@ EK_Exception
The entity being initialized is an exception object that is being thrown.
@ EK_RelatedResult
The entity being implicitly initialized back to the formal result type.
static InitializedEntity InitializeTemplateParameter(QualType T, NonTypeTemplateParmDecl *Param)
Create the initialization entity for a template parameter.
StringRef getCapturedVarName() const
For a lambda capture, return the capture's name.
SourceLocation getThrowLoc() const
Determine the location of the 'throw' keyword when initializing an exception object.
static InitializedEntity InitializeDelegation(QualType Type)
Create the initialization entity for a delegated constructor.
unsigned Index
When Kind == EK_ArrayElement, EK_VectorElement, or EK_ComplexElement, the index of the array or vecto...
static InitializedEntity InitializeCompoundLiteralInit(TypeSourceInfo *TSI)
Create the entity for a compound literal initializer.
static InitializedEntity InitializeMember(IndirectFieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
bool isVariableLengthArrayNew() const
Determine whether this is an array new with an unknown bound.
ObjCMethodDecl * MethodDecl
When Kind == EK_RelatedResult, the ObjectiveC method where result type was implicitly changed to acco...
bool isDefaultMemberInitializer() const
Is this the default member initializer of a member (specified inside the class definition)?
llvm::PointerIntPair< ParmVarDecl *, 1 > Parameter
When Kind == EK_Parameter, the ParmVarDecl, with the integer indicating whether the parameter is "con...
const CXXBaseSpecifier * getBaseSpecifier() const
Retrieve the base specifier.
SourceLocation getReturnLoc() const
Determine the location of the 'return' keyword when initializing the result of a function call.
TypeSourceInfo * getTypeSourceInfo() const
Retrieve complete type-source information for the object being constructed, if known.
ObjCMethodDecl * getMethodDecl() const
Retrieve the ObjectiveC method being initialized.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
Definition: Overload.h:951
Represents a parameter to a function.
Definition: Decl.h:1724
A (possibly-)qualified type.
Definition: Type.h:736
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:803
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:358
Encodes a location in the source.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
A container of type source information.
Definition: Type.h:6611
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6622
The base class of the type hierarchy.
Definition: Type.h:1566
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:703
QualType getType() const
Definition: Decl.h:714
Represents a variable declaration or definition.
Definition: Decl.h:915
OverloadingResult
OverloadingResult - Capture the result of performing overload resolution.
Definition: Overload.h:50
@ Result
The result type of a method or function.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:120
#define false
Definition: stdbool.h:22
#define bool
Definition: stdbool.h:20