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

source code of clang/include/clang/Sema/Initialization.h