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