1341825Sdim//===- Initialization.h - Semantic Analysis for Initializers ----*- C++ -*-===// 2212795Sdim// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6212795Sdim// 7212795Sdim//===----------------------------------------------------------------------===// 8212795Sdim// 9212795Sdim// This file provides supporting data types for initialization of objects. 10212795Sdim// 11212795Sdim//===----------------------------------------------------------------------===// 12341825Sdim 13212795Sdim#ifndef LLVM_CLANG_SEMA_INITIALIZATION_H 14212795Sdim#define LLVM_CLANG_SEMA_INITIALIZATION_H 15212795Sdim 16239462Sdim#include "clang/AST/ASTContext.h" 17249423Sdim#include "clang/AST/Attr.h" 18341825Sdim#include "clang/AST/Decl.h" 19341825Sdim#include "clang/AST/DeclAccessPair.h" 20341825Sdim#include "clang/AST/DeclarationName.h" 21341825Sdim#include "clang/AST/Expr.h" 22212795Sdim#include "clang/AST/Type.h" 23341825Sdim#include "clang/Basic/IdentifierTable.h" 24341825Sdim#include "clang/Basic/LLVM.h" 25341825Sdim#include "clang/Basic/LangOptions.h" 26212795Sdim#include "clang/Basic/SourceLocation.h" 27341825Sdim#include "clang/Basic/Specifiers.h" 28249423Sdim#include "clang/Sema/Overload.h" 29249423Sdim#include "clang/Sema/Ownership.h" 30341825Sdim#include "llvm/ADT/ArrayRef.h" 31212795Sdim#include "llvm/ADT/SmallVector.h" 32341825Sdim#include "llvm/ADT/StringRef.h" 33341825Sdim#include "llvm/ADT/iterator_range.h" 34341825Sdim#include "llvm/Support/Casting.h" 35212795Sdim#include <cassert> 36341825Sdim#include <cstdint> 37341825Sdim#include <string> 38212795Sdim 39212795Sdimnamespace clang { 40341825Sdim 41341825Sdimclass APValue; 42212795Sdimclass CXXBaseSpecifier; 43341825Sdimclass CXXConstructorDecl; 44341825Sdimclass ObjCMethodDecl; 45212795Sdimclass Sema; 46341825Sdim 47341825Sdim/// Describes an entity that is being initialized. 48341825Sdimclass alignas(8) InitializedEntity { 49212795Sdimpublic: 50341825Sdim /// Specifies the kind of entity being initialized. 51212795Sdim enum EntityKind { 52341825Sdim /// The entity being initialized is a variable. 53212795Sdim EK_Variable, 54341825Sdim 55341825Sdim /// The entity being initialized is a function parameter. 56212795Sdim EK_Parameter, 57341825Sdim 58341825Sdim /// The entity being initialized is the result of a function call. 59212795Sdim EK_Result, 60341825Sdim 61341825Sdim /// The entity being initialized is the result of a statement expression. 62341825Sdim EK_StmtExprResult, 63341825Sdim 64341825Sdim /// The entity being initialized is an exception object that 65212795Sdim /// is being thrown. 66212795Sdim EK_Exception, 67341825Sdim 68341825Sdim /// The entity being initialized is a non-static data member 69212795Sdim /// subobject. 70212795Sdim EK_Member, 71341825Sdim 72341825Sdim /// The entity being initialized is an element of an array. 73212795Sdim EK_ArrayElement, 74341825Sdim 75341825Sdim /// The entity being initialized is an object (or array of 76212795Sdim /// objects) allocated via new. 77212795Sdim EK_New, 78341825Sdim 79341825Sdim /// The entity being initialized is a temporary object. 80212795Sdim EK_Temporary, 81341825Sdim 82341825Sdim /// The entity being initialized is a base member subobject. 83212795Sdim EK_Base, 84341825Sdim 85341825Sdim /// The initialization is being done by a delegating constructor. 86221345Sdim EK_Delegating, 87341825Sdim 88341825Sdim /// The entity being initialized is an element of a vector. 89212795Sdim /// or vector. 90212795Sdim EK_VectorElement, 91341825Sdim 92341825Sdim /// The entity being initialized is a field of block descriptor for 93212795Sdim /// the copied-in c++ object. 94226633Sdim EK_BlockElement, 95341825Sdim 96321369Sdim /// The entity being initialized is a field of block descriptor for the 97321369Sdim /// copied-in lambda object that's used in the lambda to block conversion. 98321369Sdim EK_LambdaToBlockConversionBlockElement, 99341825Sdim 100341825Sdim /// The entity being initialized is the real or imaginary part of a 101226633Sdim /// complex number. 102234353Sdim EK_ComplexElement, 103341825Sdim 104341825Sdim /// The entity being initialized is the field that captures a 105234353Sdim /// variable in a lambda. 106251662Sdim EK_LambdaCapture, 107341825Sdim 108341825Sdim /// The entity being initialized is the initializer for a compound 109251662Sdim /// literal. 110261991Sdim EK_CompoundLiteralInit, 111341825Sdim 112341825Sdim /// The entity being implicitly initialized back to the formal 113261991Sdim /// result type. 114261991Sdim EK_RelatedResult, 115341825Sdim 116341825Sdim /// The entity being initialized is a function parameter; function 117261991Sdim /// is member of group of audited CF APIs. 118314564Sdim EK_Parameter_CF_Audited, 119341825Sdim 120341825Sdim /// The entity being initialized is a structured binding of a 121314564Sdim /// decomposition declaration. 122314564Sdim EK_Binding, 123261991Sdim 124261991Sdim // Note: err_init_conversion_failed in DiagnosticSemaKinds.td uses this 125261991Sdim // enum as an index for its first %select. When modifying this list, 126261991Sdim // that diagnostic text needs to be updated as well. 127212795Sdim }; 128341825Sdim 129212795Sdimprivate: 130341825Sdim /// The kind of entity being initialized. 131212795Sdim EntityKind Kind; 132212795Sdim 133341825Sdim /// If non-NULL, the parent entity in which this 134212795Sdim /// initialization occurs. 135341825Sdim const InitializedEntity *Parent = nullptr; 136212795Sdim 137341825Sdim /// The type of the object or reference being initialized. 138212795Sdim QualType Type; 139249423Sdim 140341825Sdim /// The mangling number for the next reference temporary to be created. 141341825Sdim mutable unsigned ManglingNumber = 0; 142276479Sdim 143249423Sdim struct LN { 144341825Sdim /// When Kind == EK_Result, EK_Exception, EK_New, the 145249423Sdim /// location of the 'return', 'throw', or 'new' keyword, 146249423Sdim /// respectively. When Kind == EK_Temporary, the location where 147249423Sdim /// the temporary is being created. 148249423Sdim unsigned Location; 149249423Sdim 150341825Sdim /// Whether the entity being initialized may end up using the 151249423Sdim /// named return value optimization (NRVO). 152249423Sdim bool NRVO; 153249423Sdim }; 154249423Sdim 155314564Sdim struct VD { 156341825Sdim /// The VarDecl, FieldDecl, or BindingDecl being initialized. 157314564Sdim ValueDecl *VariableOrMember; 158314564Sdim 159341825Sdim /// When Kind == EK_Member, whether this is an implicit member 160314564Sdim /// initialization in a copy or move constructor. These can perform array 161314564Sdim /// copies. 162314564Sdim bool IsImplicitFieldInit; 163341825Sdim 164341825Sdim /// When Kind == EK_Member, whether this is the initial initialization 165341825Sdim /// check for a default member initializer. 166341825Sdim bool IsDefaultMemberInit; 167314564Sdim }; 168314564Sdim 169249423Sdim struct C { 170341825Sdim /// The name of the variable being captured by an EK_LambdaCapture. 171261991Sdim IdentifierInfo *VarID; 172249423Sdim 173341825Sdim /// The source location at which the capture occurs. 174249423Sdim unsigned Location; 175249423Sdim }; 176249423Sdim 177212795Sdim union { 178341825Sdim /// When Kind == EK_Variable, EK_Member or EK_Binding, the variable. 179314564Sdim VD Variable; 180341825Sdim 181341825Sdim /// When Kind == EK_RelatedResult, the ObjectiveC method where 182261991Sdim /// result type was implicitly changed to accommodate ARC semantics. 183261991Sdim ObjCMethodDecl *MethodDecl; 184224145Sdim 185341825Sdim /// When Kind == EK_Parameter, the ParmVarDecl, with the 186224145Sdim /// low bit indicating whether the parameter is "consumed". 187224145Sdim uintptr_t Parameter; 188341825Sdim 189341825Sdim /// When Kind == EK_Temporary or EK_CompoundLiteralInit, the type 190251662Sdim /// source information for the temporary. 191218893Sdim TypeSourceInfo *TypeInfo; 192249423Sdim 193249423Sdim struct LN LocAndNRVO; 194341825Sdim 195341825Sdim /// When Kind == EK_Base, the base specifier that provides the 196212795Sdim /// base class. The lower bit specifies whether the base is an inherited 197212795Sdim /// virtual base. 198212795Sdim uintptr_t Base; 199212795Sdim 200341825Sdim /// When Kind == EK_ArrayElement, EK_VectorElement, or 201226633Sdim /// EK_ComplexElement, the index of the array or vector element being 202341825Sdim /// initialized. 203212795Sdim unsigned Index; 204249423Sdim 205249423Sdim struct C Capture; 206212795Sdim }; 207212795Sdim 208341825Sdim InitializedEntity() = default; 209212795Sdim 210341825Sdim /// Create the initialization entity for a variable. 211314564Sdim InitializedEntity(VarDecl *Var, EntityKind EK = EK_Variable) 212341825Sdim : Kind(EK), Type(Var->getType()), Variable{Var, false, false} {} 213341825Sdim 214341825Sdim /// Create the initialization entity for the result of a 215212795Sdim /// function, throwing an object, performing an explicit cast, or 216212795Sdim /// initializing a parameter for which there is no declaration. 217212795Sdim InitializedEntity(EntityKind Kind, SourceLocation Loc, QualType Type, 218212795Sdim bool NRVO = false) 219341825Sdim : Kind(Kind), Type(Type) { 220212795Sdim LocAndNRVO.Location = Loc.getRawEncoding(); 221212795Sdim LocAndNRVO.NRVO = NRVO; 222212795Sdim } 223341825Sdim 224341825Sdim /// Create the initialization entity for a member subobject. 225314564Sdim InitializedEntity(FieldDecl *Member, const InitializedEntity *Parent, 226341825Sdim bool Implicit, bool DefaultMemberInit) 227341825Sdim : Kind(EK_Member), Parent(Parent), Type(Member->getType()), 228341825Sdim Variable{Member, Implicit, DefaultMemberInit} {} 229341825Sdim 230341825Sdim /// Create the initialization entity for an array element. 231341825Sdim InitializedEntity(ASTContext &Context, unsigned Index, 232212795Sdim const InitializedEntity &Parent); 233212795Sdim 234341825Sdim /// Create the initialization entity for a lambda capture. 235261991Sdim InitializedEntity(IdentifierInfo *VarID, QualType FieldType, SourceLocation Loc) 236341825Sdim : Kind(EK_LambdaCapture), Type(FieldType) { 237261991Sdim Capture.VarID = VarID; 238234353Sdim Capture.Location = Loc.getRawEncoding(); 239234353Sdim } 240341825Sdim 241212795Sdimpublic: 242341825Sdim /// Create the initialization entity for a variable. 243212795Sdim static InitializedEntity InitializeVariable(VarDecl *Var) { 244212795Sdim return InitializedEntity(Var); 245212795Sdim } 246249423Sdim 247341825Sdim /// Create the initialization entity for a parameter. 248218893Sdim static InitializedEntity InitializeParameter(ASTContext &Context, 249314564Sdim const ParmVarDecl *Parm) { 250249423Sdim return InitializeParameter(Context, Parm, Parm->getType()); 251249423Sdim } 252249423Sdim 253341825Sdim /// Create the initialization entity for a parameter, but use 254249423Sdim /// another type. 255249423Sdim static InitializedEntity InitializeParameter(ASTContext &Context, 256314564Sdim const ParmVarDecl *Parm, 257249423Sdim QualType Type) { 258234353Sdim bool Consumed = (Context.getLangOpts().ObjCAutoRefCount && 259224145Sdim Parm->hasAttr<NSConsumedAttr>()); 260224145Sdim 261224145Sdim InitializedEntity Entity; 262224145Sdim Entity.Kind = EK_Parameter; 263249423Sdim Entity.Type = 264249423Sdim Context.getVariableArrayDecayedType(Type.getUnqualifiedType()); 265276479Sdim Entity.Parent = nullptr; 266224145Sdim Entity.Parameter 267224145Sdim = (static_cast<uintptr_t>(Consumed) | reinterpret_cast<uintptr_t>(Parm)); 268224145Sdim return Entity; 269212795Sdim } 270212795Sdim 271341825Sdim /// Create the initialization entity for a parameter that is 272212795Sdim /// only known by its type. 273218893Sdim static InitializedEntity InitializeParameter(ASTContext &Context, 274224145Sdim QualType Type, 275224145Sdim bool Consumed) { 276212795Sdim InitializedEntity Entity; 277212795Sdim Entity.Kind = EK_Parameter; 278218893Sdim Entity.Type = Context.getVariableArrayDecayedType(Type); 279276479Sdim Entity.Parent = nullptr; 280224145Sdim Entity.Parameter = (Consumed); 281212795Sdim return Entity; 282212795Sdim } 283212795Sdim 284341825Sdim /// Create the initialization entity for the result of a function. 285212795Sdim static InitializedEntity InitializeResult(SourceLocation ReturnLoc, 286212795Sdim QualType Type, bool NRVO) { 287212795Sdim return InitializedEntity(EK_Result, ReturnLoc, Type, NRVO); 288212795Sdim } 289212795Sdim 290341825Sdim static InitializedEntity InitializeStmtExprResult(SourceLocation ReturnLoc, 291341825Sdim QualType Type) { 292341825Sdim return InitializedEntity(EK_StmtExprResult, ReturnLoc, Type); 293341825Sdim } 294341825Sdim 295212795Sdim static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc, 296212795Sdim QualType Type, bool NRVO) { 297212795Sdim return InitializedEntity(EK_BlockElement, BlockVarLoc, Type, NRVO); 298212795Sdim } 299321369Sdim 300321369Sdim static InitializedEntity InitializeLambdaToBlock(SourceLocation BlockVarLoc, 301321369Sdim QualType Type, bool NRVO) { 302321369Sdim return InitializedEntity(EK_LambdaToBlockConversionBlockElement, 303321369Sdim BlockVarLoc, Type, NRVO); 304321369Sdim } 305321369Sdim 306341825Sdim /// Create the initialization entity for an exception object. 307212795Sdim static InitializedEntity InitializeException(SourceLocation ThrowLoc, 308212795Sdim QualType Type, bool NRVO) { 309212795Sdim return InitializedEntity(EK_Exception, ThrowLoc, Type, NRVO); 310212795Sdim } 311212795Sdim 312341825Sdim /// Create the initialization entity for an object allocated via new. 313212795Sdim static InitializedEntity InitializeNew(SourceLocation NewLoc, QualType Type) { 314212795Sdim return InitializedEntity(EK_New, NewLoc, Type); 315212795Sdim } 316341825Sdim 317341825Sdim /// Create the initialization entity for a temporary. 318212795Sdim static InitializedEntity InitializeTemporary(QualType Type) { 319321369Sdim return InitializeTemporary(nullptr, Type); 320212795Sdim } 321218893Sdim 322341825Sdim /// Create the initialization entity for a temporary. 323218893Sdim static InitializedEntity InitializeTemporary(TypeSourceInfo *TypeInfo) { 324321369Sdim return InitializeTemporary(TypeInfo, TypeInfo->getType()); 325321369Sdim } 326341825Sdim 327341825Sdim /// Create the initialization entity for a temporary. 328321369Sdim static InitializedEntity InitializeTemporary(TypeSourceInfo *TypeInfo, 329321369Sdim QualType Type) { 330321369Sdim InitializedEntity Result(EK_Temporary, SourceLocation(), Type); 331218893Sdim Result.TypeInfo = TypeInfo; 332218893Sdim return Result; 333218893Sdim } 334341825Sdim 335341825Sdim /// Create the initialization entity for a related result. 336261991Sdim static InitializedEntity InitializeRelatedResult(ObjCMethodDecl *MD, 337261991Sdim QualType Type) { 338261991Sdim InitializedEntity Result(EK_RelatedResult, SourceLocation(), Type); 339261991Sdim Result.MethodDecl = MD; 340261991Sdim return Result; 341261991Sdim } 342218893Sdim 343341825Sdim /// Create the initialization entity for a base class subobject. 344309124Sdim static InitializedEntity 345309124Sdim InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, 346309124Sdim bool IsInheritedVirtualBase, 347309124Sdim const InitializedEntity *Parent = nullptr); 348221345Sdim 349341825Sdim /// Create the initialization entity for a delegated constructor. 350221345Sdim static InitializedEntity InitializeDelegation(QualType Type) { 351221345Sdim return InitializedEntity(EK_Delegating, SourceLocation(), Type); 352221345Sdim } 353341825Sdim 354341825Sdim /// Create the initialization entity for a member subobject. 355276479Sdim static InitializedEntity 356276479Sdim InitializeMember(FieldDecl *Member, 357314564Sdim const InitializedEntity *Parent = nullptr, 358314564Sdim bool Implicit = false) { 359341825Sdim return InitializedEntity(Member, Parent, Implicit, false); 360212795Sdim } 361341825Sdim 362341825Sdim /// Create the initialization entity for a member subobject. 363276479Sdim static InitializedEntity 364276479Sdim InitializeMember(IndirectFieldDecl *Member, 365314564Sdim const InitializedEntity *Parent = nullptr, 366314564Sdim bool Implicit = false) { 367341825Sdim return InitializedEntity(Member->getAnonField(), Parent, Implicit, false); 368218893Sdim } 369218893Sdim 370341825Sdim /// Create the initialization entity for a default member initializer. 371341825Sdim static InitializedEntity 372341825Sdim InitializeMemberFromDefaultMemberInitializer(FieldDecl *Member) { 373341825Sdim return InitializedEntity(Member, nullptr, false, true); 374341825Sdim } 375341825Sdim 376341825Sdim /// Create the initialization entity for an array element. 377341825Sdim static InitializedEntity InitializeElement(ASTContext &Context, 378341825Sdim unsigned Index, 379212795Sdim const InitializedEntity &Parent) { 380212795Sdim return InitializedEntity(Context, Index, Parent); 381212795Sdim } 382212795Sdim 383341825Sdim /// Create the initialization entity for a structured binding. 384314564Sdim static InitializedEntity InitializeBinding(VarDecl *Binding) { 385314564Sdim return InitializedEntity(Binding, EK_Binding); 386314564Sdim } 387314564Sdim 388341825Sdim /// Create the initialization entity for a lambda capture. 389353358Sdim /// 390353358Sdim /// \p VarID The name of the entity being captured, or nullptr for 'this'. 391261991Sdim static InitializedEntity InitializeLambdaCapture(IdentifierInfo *VarID, 392261991Sdim QualType FieldType, 393234353Sdim SourceLocation Loc) { 394261991Sdim return InitializedEntity(VarID, FieldType, Loc); 395234353Sdim } 396251662Sdim 397341825Sdim /// Create the entity for a compound literal initializer. 398251662Sdim static InitializedEntity InitializeCompoundLiteralInit(TypeSourceInfo *TSI) { 399251662Sdim InitializedEntity Result(EK_CompoundLiteralInit, SourceLocation(), 400251662Sdim TSI->getType()); 401251662Sdim Result.TypeInfo = TSI; 402251662Sdim return Result; 403251662Sdim } 404251662Sdim 405341825Sdim /// Determine the kind of initialization. 406341825Sdim EntityKind getKind() const { return Kind; } 407251662Sdim 408341825Sdim /// Retrieve the parent of the entity being initialized, when 409221345Sdim /// the initialization itself is occurring within the context of a 410212795Sdim /// larger initialization. 411212795Sdim const InitializedEntity *getParent() const { return Parent; } 412212795Sdim 413341825Sdim /// Retrieve type being initialized. 414212795Sdim QualType getType() const { return Type; } 415341825Sdim 416341825Sdim /// Retrieve complete type-source information for the object being 417218893Sdim /// constructed, if known. 418218893Sdim TypeSourceInfo *getTypeSourceInfo() const { 419251662Sdim if (Kind == EK_Temporary || Kind == EK_CompoundLiteralInit) 420218893Sdim return TypeInfo; 421341825Sdim 422276479Sdim return nullptr; 423218893Sdim } 424341825Sdim 425341825Sdim /// Retrieve the name of the entity being initialized. 426212795Sdim DeclarationName getName() const; 427212795Sdim 428341825Sdim /// Retrieve the variable, parameter, or field being 429212795Sdim /// initialized. 430314564Sdim ValueDecl *getDecl() const; 431341825Sdim 432341825Sdim /// Retrieve the ObjectiveC method being initialized. 433261991Sdim ObjCMethodDecl *getMethodDecl() const { return MethodDecl; } 434212795Sdim 435341825Sdim /// Determine whether this initialization allows the named return 436212795Sdim /// value optimization, which also applies to thrown objects. 437212795Sdim bool allowsNRVO() const; 438224145Sdim 439261991Sdim bool isParameterKind() const { 440261991Sdim return (getKind() == EK_Parameter || 441261991Sdim getKind() == EK_Parameter_CF_Audited); 442261991Sdim } 443341825Sdim 444341825Sdim /// Determine whether this initialization consumes the 445224145Sdim /// parameter. 446224145Sdim bool isParameterConsumed() const { 447261991Sdim assert(isParameterKind() && "Not a parameter"); 448224145Sdim return (Parameter & 1); 449224145Sdim } 450341825Sdim 451341825Sdim /// Retrieve the base specifier. 452261991Sdim const CXXBaseSpecifier *getBaseSpecifier() const { 453212795Sdim assert(getKind() == EK_Base && "Not a base specifier"); 454261991Sdim return reinterpret_cast<const CXXBaseSpecifier *>(Base & ~0x1); 455212795Sdim } 456212795Sdim 457341825Sdim /// Return whether the base is an inherited virtual base. 458212795Sdim bool isInheritedVirtualBase() const { 459212795Sdim assert(getKind() == EK_Base && "Not a base specifier"); 460212795Sdim return Base & 0x1; 461212795Sdim } 462212795Sdim 463341825Sdim /// Determine whether this is an array new with an unknown bound. 464314564Sdim bool isVariableLengthArrayNew() const { 465314564Sdim return getKind() == EK_New && dyn_cast_or_null<IncompleteArrayType>( 466314564Sdim getType()->getAsArrayTypeUnsafe()); 467314564Sdim } 468314564Sdim 469341825Sdim /// Is this the implicit initialization of a member of a class from 470314564Sdim /// a defaulted constructor? 471314564Sdim bool isImplicitMemberInitializer() const { 472314564Sdim return getKind() == EK_Member && Variable.IsImplicitFieldInit; 473314564Sdim } 474314564Sdim 475341825Sdim /// Is this the default member initializer of a member (specified inside 476341825Sdim /// the class definition)? 477341825Sdim bool isDefaultMemberInitializer() const { 478341825Sdim return getKind() == EK_Member && Variable.IsDefaultMemberInit; 479341825Sdim } 480341825Sdim 481341825Sdim /// Determine the location of the 'return' keyword when initializing 482212795Sdim /// the result of a function call. 483212795Sdim SourceLocation getReturnLoc() const { 484212795Sdim assert(getKind() == EK_Result && "No 'return' location!"); 485212795Sdim return SourceLocation::getFromRawEncoding(LocAndNRVO.Location); 486212795Sdim } 487224145Sdim 488341825Sdim /// Determine the location of the 'throw' keyword when initializing 489212795Sdim /// an exception object. 490212795Sdim SourceLocation getThrowLoc() const { 491212795Sdim assert(getKind() == EK_Exception && "No 'throw' location!"); 492212795Sdim return SourceLocation::getFromRawEncoding(LocAndNRVO.Location); 493212795Sdim } 494212795Sdim 495341825Sdim /// If this is an array, vector, or complex number element, get the 496276479Sdim /// element's index. 497276479Sdim unsigned getElementIndex() const { 498276479Sdim assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement || 499276479Sdim getKind() == EK_ComplexElement); 500276479Sdim return Index; 501276479Sdim } 502341825Sdim 503341825Sdim /// If this is already the initializer for an array or vector 504212795Sdim /// element, sets the element index. 505212795Sdim void setElementIndex(unsigned Index) { 506226633Sdim assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement || 507234353Sdim getKind() == EK_ComplexElement); 508212795Sdim this->Index = Index; 509212795Sdim } 510341825Sdim 511341825Sdim /// For a lambda capture, return the capture's name. 512261991Sdim StringRef getCapturedVarName() const { 513234353Sdim assert(getKind() == EK_LambdaCapture && "Not a lambda capture!"); 514353358Sdim return Capture.VarID ? Capture.VarID->getName() : "this"; 515234353Sdim } 516341825Sdim 517341825Sdim /// Determine the location of the capture when initializing 518234353Sdim /// field from a captured variable in a lambda. 519234353Sdim SourceLocation getCaptureLoc() const { 520234353Sdim assert(getKind() == EK_LambdaCapture && "Not a lambda capture!"); 521234353Sdim return SourceLocation::getFromRawEncoding(Capture.Location); 522234353Sdim } 523341825Sdim 524261991Sdim void setParameterCFAudited() { 525261991Sdim Kind = EK_Parameter_CF_Audited; 526261991Sdim } 527261991Sdim 528276479Sdim unsigned allocateManglingNumber() const { return ++ManglingNumber; } 529276479Sdim 530261991Sdim /// Dump a representation of the initialized entity to standard error, 531261991Sdim /// for debugging purposes. 532261991Sdim void dump() const; 533261991Sdim 534261991Sdimprivate: 535261991Sdim unsigned dumpImpl(raw_ostream &OS) const; 536212795Sdim}; 537341825Sdim 538341825Sdim/// Describes the kind of initialization being performed, along with 539212795Sdim/// location information for tokens related to the initialization (equal sign, 540212795Sdim/// parentheses). 541212795Sdimclass InitializationKind { 542212795Sdimpublic: 543341825Sdim /// The kind of initialization being performed. 544212795Sdim enum InitKind { 545341825Sdim /// Direct initialization 546341825Sdim IK_Direct, 547341825Sdim 548341825Sdim /// Direct list-initialization 549341825Sdim IK_DirectList, 550341825Sdim 551341825Sdim /// Copy initialization 552341825Sdim IK_Copy, 553341825Sdim 554341825Sdim /// Default initialization 555341825Sdim IK_Default, 556341825Sdim 557341825Sdim /// Value initialization 558341825Sdim IK_Value 559212795Sdim }; 560341825Sdim 561212795Sdimprivate: 562341825Sdim /// The context of the initialization. 563234353Sdim enum InitContext { 564341825Sdim /// Normal context 565341825Sdim IC_Normal, 566341825Sdim 567341825Sdim /// Normal context, but allows explicit conversion functionss 568341825Sdim IC_ExplicitConvs, 569341825Sdim 570341825Sdim /// Implicit context (value initialization) 571341825Sdim IC_Implicit, 572341825Sdim 573341825Sdim /// Static cast context 574341825Sdim IC_StaticCast, 575341825Sdim 576341825Sdim /// C-style cast context 577341825Sdim IC_CStyleCast, 578341825Sdim 579341825Sdim /// Functional cast context 580341825Sdim IC_FunctionalCast 581212795Sdim }; 582341825Sdim 583341825Sdim /// The kind of initialization being performed. 584234353Sdim InitKind Kind : 8; 585234353Sdim 586341825Sdim /// The context of the initialization. 587234353Sdim InitContext Context : 8; 588341825Sdim 589341825Sdim /// The source locations involved in the initialization. 590212795Sdim SourceLocation Locations[3]; 591341825Sdim 592341825Sdim InitializationKind(InitKind Kind, InitContext Context, SourceLocation Loc1, 593212795Sdim SourceLocation Loc2, SourceLocation Loc3) 594341825Sdim : Kind(Kind), Context(Context) { 595212795Sdim Locations[0] = Loc1; 596212795Sdim Locations[1] = Loc2; 597212795Sdim Locations[2] = Loc3; 598212795Sdim } 599341825Sdim 600212795Sdimpublic: 601341825Sdim /// Create a direct initialization. 602212795Sdim static InitializationKind CreateDirect(SourceLocation InitLoc, 603212795Sdim SourceLocation LParenLoc, 604212795Sdim SourceLocation RParenLoc) { 605234353Sdim return InitializationKind(IK_Direct, IC_Normal, 606234353Sdim InitLoc, LParenLoc, RParenLoc); 607212795Sdim } 608212795Sdim 609234353Sdim static InitializationKind CreateDirectList(SourceLocation InitLoc) { 610341825Sdim return InitializationKind(IK_DirectList, IC_Normal, InitLoc, InitLoc, 611341825Sdim InitLoc); 612234353Sdim } 613234353Sdim 614341825Sdim static InitializationKind CreateDirectList(SourceLocation InitLoc, 615341825Sdim SourceLocation LBraceLoc, 616341825Sdim SourceLocation RBraceLoc) { 617341825Sdim return InitializationKind(IK_DirectList, IC_Normal, InitLoc, LBraceLoc, 618341825Sdim RBraceLoc); 619341825Sdim } 620341825Sdim 621341825Sdim /// Create a direct initialization due to a cast that isn't a C-style 622224145Sdim /// or functional cast. 623224145Sdim static InitializationKind CreateCast(SourceRange TypeRange) { 624234353Sdim return InitializationKind(IK_Direct, IC_StaticCast, TypeRange.getBegin(), 625234353Sdim TypeRange.getBegin(), TypeRange.getEnd()); 626212795Sdim } 627341825Sdim 628341825Sdim /// Create a direct initialization for a C-style cast. 629224145Sdim static InitializationKind CreateCStyleCast(SourceLocation StartLoc, 630234353Sdim SourceRange TypeRange, 631234353Sdim bool InitList) { 632234353Sdim // C++ cast syntax doesn't permit init lists, but C compound literals are 633234353Sdim // exactly that. 634234353Sdim return InitializationKind(InitList ? IK_DirectList : IK_Direct, 635234353Sdim IC_CStyleCast, StartLoc, TypeRange.getBegin(), 636224145Sdim TypeRange.getEnd()); 637224145Sdim } 638224145Sdim 639341825Sdim /// Create a direct initialization for a functional cast. 640234353Sdim static InitializationKind CreateFunctionalCast(SourceRange TypeRange, 641234353Sdim bool InitList) { 642234353Sdim return InitializationKind(InitList ? IK_DirectList : IK_Direct, 643234353Sdim IC_FunctionalCast, TypeRange.getBegin(), 644234353Sdim TypeRange.getBegin(), TypeRange.getEnd()); 645224145Sdim } 646224145Sdim 647341825Sdim /// Create a copy initialization. 648212795Sdim static InitializationKind CreateCopy(SourceLocation InitLoc, 649234353Sdim SourceLocation EqualLoc, 650234353Sdim bool AllowExplicitConvs = false) { 651341825Sdim return InitializationKind(IK_Copy, 652234353Sdim AllowExplicitConvs? IC_ExplicitConvs : IC_Normal, 653234353Sdim InitLoc, EqualLoc, EqualLoc); 654212795Sdim } 655341825Sdim 656341825Sdim /// Create a default initialization. 657212795Sdim static InitializationKind CreateDefault(SourceLocation InitLoc) { 658234353Sdim return InitializationKind(IK_Default, IC_Normal, InitLoc, InitLoc, InitLoc); 659212795Sdim } 660341825Sdim 661341825Sdim /// Create a value initialization. 662212795Sdim static InitializationKind CreateValue(SourceLocation InitLoc, 663212795Sdim SourceLocation LParenLoc, 664212795Sdim SourceLocation RParenLoc, 665212795Sdim bool isImplicit = false) { 666234353Sdim return InitializationKind(IK_Value, isImplicit ? IC_Implicit : IC_Normal, 667212795Sdim InitLoc, LParenLoc, RParenLoc); 668212795Sdim } 669321369Sdim 670341825Sdim /// Create an initialization from an initializer (which, for direct 671321369Sdim /// initialization from a parenthesized list, will be a ParenListExpr). 672321369Sdim static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, 673321369Sdim Expr *Init) { 674321369Sdim if (!Init) return CreateDefault(Loc); 675344779Sdim if (!DirectInit) 676344779Sdim return CreateCopy(Loc, Init->getBeginLoc()); 677341825Sdim if (isa<InitListExpr>(Init)) 678344779Sdim return CreateDirectList(Loc, Init->getBeginLoc(), Init->getEndLoc()); 679344779Sdim return CreateDirect(Loc, Init->getBeginLoc(), Init->getEndLoc()); 680321369Sdim } 681341825Sdim 682341825Sdim /// Determine the initialization kind. 683212795Sdim InitKind getKind() const { 684234353Sdim return Kind; 685212795Sdim } 686341825Sdim 687341825Sdim /// Determine whether this initialization is an explicit cast. 688212795Sdim bool isExplicitCast() const { 689234353Sdim return Context >= IC_StaticCast; 690212795Sdim } 691341825Sdim 692341825Sdim /// Determine whether this initialization is a C-style cast. 693341825Sdim bool isCStyleOrFunctionalCast() const { 694341825Sdim return Context >= IC_CStyleCast; 695212795Sdim } 696212795Sdim 697341825Sdim /// Determine whether this is a C-style cast. 698224145Sdim bool isCStyleCast() const { 699234353Sdim return Context == IC_CStyleCast; 700224145Sdim } 701224145Sdim 702341825Sdim /// Determine whether this is a functional-style cast. 703224145Sdim bool isFunctionalCast() const { 704234353Sdim return Context == IC_FunctionalCast; 705224145Sdim } 706224145Sdim 707341825Sdim /// Determine whether this initialization is an implicit 708212795Sdim /// value-initialization, e.g., as occurs during aggregate 709212795Sdim /// initialization. 710234353Sdim bool isImplicitValueInit() const { return Context == IC_Implicit; } 711212795Sdim 712341825Sdim /// Retrieve the location at which initialization is occurring. 713212795Sdim SourceLocation getLocation() const { return Locations[0]; } 714341825Sdim 715341825Sdim /// Retrieve the source range that covers the initialization. 716341825Sdim SourceRange getRange() const { 717212795Sdim return SourceRange(Locations[0], Locations[2]); 718212795Sdim } 719341825Sdim 720341825Sdim /// Retrieve the location of the equal sign for copy initialization 721212795Sdim /// (if present). 722212795Sdim SourceLocation getEqualLoc() const { 723234353Sdim assert(Kind == IK_Copy && "Only copy initialization has an '='"); 724212795Sdim return Locations[1]; 725212795Sdim } 726234353Sdim 727234353Sdim bool isCopyInit() const { return Kind == IK_Copy; } 728234353Sdim 729341825Sdim /// Retrieve whether this initialization allows the use of explicit 730234353Sdim /// constructors. 731234353Sdim bool AllowExplicit() const { return !isCopyInit(); } 732234353Sdim 733341825Sdim /// Retrieve whether this initialization allows the use of explicit 734261991Sdim /// conversion functions when binding a reference. If the reference is the 735261991Sdim /// first parameter in a copy or move constructor, such conversions are 736261991Sdim /// permitted even though we are performing copy-initialization. 737261991Sdim bool allowExplicitConversionFunctionsInRefBinding() const { 738234353Sdim return !isCopyInit() || Context == IC_ExplicitConvs; 739234353Sdim } 740341825Sdim 741341825Sdim /// Determine whether this initialization has a source range containing the 742341825Sdim /// locations of open and closing parentheses or braces. 743341825Sdim bool hasParenOrBraceRange() const { 744341825Sdim return Kind == IK_Direct || Kind == IK_Value || Kind == IK_DirectList; 745341825Sdim } 746341825Sdim 747341825Sdim /// Retrieve the source range containing the locations of the open 748341825Sdim /// and closing parentheses or braces for value, direct, and direct list 749341825Sdim /// initializations. 750341825Sdim SourceRange getParenOrBraceRange() const { 751341825Sdim assert(hasParenOrBraceRange() && "Only direct, value, and direct-list " 752341825Sdim "initialization have parentheses or " 753341825Sdim "braces"); 754212795Sdim return SourceRange(Locations[1], Locations[2]); 755212795Sdim } 756212795Sdim}; 757212795Sdim 758341825Sdim/// Describes the sequence of initializations required to initialize 759212795Sdim/// a given object or reference with a set of arguments. 760212795Sdimclass InitializationSequence { 761212795Sdimpublic: 762341825Sdim /// Describes the kind of initialization sequence computed. 763212795Sdim enum SequenceKind { 764341825Sdim /// A failed initialization sequence. The failure kind tells what 765212795Sdim /// happened. 766212795Sdim FailedSequence = 0, 767223017Sdim 768341825Sdim /// A dependent initialization, which could not be 769212795Sdim /// type-checked due to the presence of dependent types or 770223017Sdim /// dependently-typed expressions. 771212795Sdim DependentSequence, 772212795Sdim 773341825Sdim /// A normal sequence. 774224145Sdim NormalSequence 775212795Sdim }; 776341825Sdim 777341825Sdim /// Describes the kind of a particular step in an initialization 778212795Sdim /// sequence. 779212795Sdim enum StepKind { 780341825Sdim /// Resolve the address of an overloaded function to a specific 781212795Sdim /// function declaration. 782212795Sdim SK_ResolveAddressOfOverloadedFunction, 783341825Sdim 784341825Sdim /// Perform a derived-to-base cast, producing an rvalue. 785212795Sdim SK_CastDerivedToBaseRValue, 786341825Sdim 787341825Sdim /// Perform a derived-to-base cast, producing an xvalue. 788212795Sdim SK_CastDerivedToBaseXValue, 789341825Sdim 790341825Sdim /// Perform a derived-to-base cast, producing an lvalue. 791212795Sdim SK_CastDerivedToBaseLValue, 792341825Sdim 793341825Sdim /// Reference binding to an lvalue. 794212795Sdim SK_BindReference, 795341825Sdim 796341825Sdim /// Reference binding to a temporary. 797212795Sdim SK_BindReferenceToTemporary, 798341825Sdim 799341825Sdim /// An optional copy of a temporary object to another 800212795Sdim /// temporary object, which is permitted (but not required) by 801212795Sdim /// C++98/03 but not C++0x. 802212795Sdim SK_ExtraneousCopyToTemporary, 803341825Sdim 804341825Sdim /// Direct-initialization from a reference-related object in the 805314564Sdim /// final stage of class copy-initialization. 806314564Sdim SK_FinalCopy, 807341825Sdim 808341825Sdim /// Perform a user-defined conversion, either via a conversion 809212795Sdim /// function or via a constructor. 810212795Sdim SK_UserConversion, 811341825Sdim 812341825Sdim /// Perform a qualification conversion, producing an rvalue. 813212795Sdim SK_QualificationConversionRValue, 814341825Sdim 815341825Sdim /// Perform a qualification conversion, producing an xvalue. 816212795Sdim SK_QualificationConversionXValue, 817341825Sdim 818341825Sdim /// Perform a qualification conversion, producing an lvalue. 819212795Sdim SK_QualificationConversionLValue, 820341825Sdim 821341825Sdim /// Perform a conversion adding _Atomic to a type. 822276479Sdim SK_AtomicConversion, 823341825Sdim 824341825Sdim /// Perform an implicit conversion sequence. 825212795Sdim SK_ConversionSequence, 826341825Sdim 827341825Sdim /// Perform an implicit conversion sequence without narrowing. 828261991Sdim SK_ConversionSequenceNoNarrowing, 829341825Sdim 830341825Sdim /// Perform list-initialization without a constructor. 831212795Sdim SK_ListInitialization, 832341825Sdim 833341825Sdim /// Unwrap the single-element initializer list for a reference. 834234353Sdim SK_UnwrapInitList, 835341825Sdim 836341825Sdim /// Rewrap the single-element initializer list for a reference. 837234353Sdim SK_RewrapInitList, 838341825Sdim 839341825Sdim /// Perform initialization via a constructor. 840212795Sdim SK_ConstructorInitialization, 841341825Sdim 842341825Sdim /// Perform initialization via a constructor, taking arguments from 843276479Sdim /// a single InitListExpr. 844276479Sdim SK_ConstructorInitializationFromList, 845341825Sdim 846341825Sdim /// Zero-initialize the object 847212795Sdim SK_ZeroInitialization, 848341825Sdim 849341825Sdim /// C assignment 850212795Sdim SK_CAssignment, 851341825Sdim 852341825Sdim /// Initialization by string 853212795Sdim SK_StringInit, 854341825Sdim 855341825Sdim /// An initialization that "converts" an Objective-C object 856212795Sdim /// (not a point to an object) to another Objective-C object type. 857219077Sdim SK_ObjCObjectConversion, 858341825Sdim 859341825Sdim /// Array indexing for initialization by elementwise copy. 860314564Sdim SK_ArrayLoopIndex, 861341825Sdim 862341825Sdim /// Array initialization by elementwise copy. 863314564Sdim SK_ArrayLoopInit, 864341825Sdim 865341825Sdim /// Array initialization (from an array rvalue). 866224145Sdim SK_ArrayInit, 867341825Sdim 868341825Sdim /// Array initialization (from an array rvalue) as a GNU extension. 869314564Sdim SK_GNUArrayInit, 870341825Sdim 871341825Sdim /// Array initialization from a parenthesized initializer list. 872234353Sdim /// This is a GNU C++ extension. 873234353Sdim SK_ParenthesizedArrayInit, 874341825Sdim 875341825Sdim /// Pass an object by indirect copy-and-restore. 876224145Sdim SK_PassByIndirectCopyRestore, 877341825Sdim 878341825Sdim /// Pass an object by indirect restore. 879224145Sdim SK_PassByIndirectRestore, 880341825Sdim 881341825Sdim /// Produce an Objective-C object pointer. 882234353Sdim SK_ProduceObjCObject, 883341825Sdim 884341825Sdim /// Construct a std::initializer_list from an initializer list. 885249423Sdim SK_StdInitializerList, 886341825Sdim 887341825Sdim /// Perform initialization via a constructor taking a single 888276479Sdim /// std::initializer_list argument. 889276479Sdim SK_StdInitializerListConstructorCall, 890341825Sdim 891341825Sdim /// Initialize an OpenCL sampler from an integer. 892249423Sdim SK_OCLSamplerInit, 893341825Sdim 894344779Sdim /// Initialize an opaque OpenCL type (event_t, queue_t, etc.) with zero 895344779Sdim SK_OCLZeroOpaqueType 896212795Sdim }; 897341825Sdim 898341825Sdim /// A single step in the initialization sequence. 899212795Sdim class Step { 900212795Sdim public: 901341825Sdim /// The kind of conversion or initialization step we are taking. 902212795Sdim StepKind Kind; 903341825Sdim 904341825Sdim // The type that results from this initialization. 905212795Sdim QualType Type; 906249423Sdim 907249423Sdim struct F { 908249423Sdim bool HadMultipleCandidates; 909249423Sdim FunctionDecl *Function; 910249423Sdim DeclAccessPair FoundDecl; 911249423Sdim }; 912249423Sdim 913212795Sdim union { 914341825Sdim /// When Kind == SK_ResolvedOverloadedFunction or Kind == 915341825Sdim /// SK_UserConversion, the function that the expression should be 916212795Sdim /// resolved to or the conversion function to call, respectively. 917226633Sdim /// When Kind == SK_ConstructorInitialization or SK_ListConstruction, 918226633Sdim /// the constructor to be called. 919212795Sdim /// 920226633Sdim /// Always a FunctionDecl, plus a Boolean flag telling if it was 921226633Sdim /// selected from an overloaded set having size greater than 1. 922212795Sdim /// For conversion decls, the naming class is the source type. 923212795Sdim /// For construct decls, the naming class is the target type. 924249423Sdim struct F Function; 925226633Sdim 926341825Sdim /// When Kind = SK_ConversionSequence, the implicit conversion 927234353Sdim /// sequence. 928212795Sdim ImplicitConversionSequence *ICS; 929234353Sdim 930341825Sdim /// When Kind = SK_RewrapInitList, the syntactic form of the 931234353Sdim /// wrapping list. 932234353Sdim InitListExpr *WrappingSyntacticList; 933212795Sdim }; 934226633Sdim 935212795Sdim void Destroy(); 936212795Sdim }; 937341825Sdim 938212795Sdimprivate: 939341825Sdim /// The kind of initialization sequence computed. 940212795Sdim enum SequenceKind SequenceKind; 941341825Sdim 942341825Sdim /// Steps taken by this initialization. 943226633Sdim SmallVector<Step, 4> Steps; 944341825Sdim 945212795Sdimpublic: 946341825Sdim /// Describes why initialization failed. 947212795Sdim enum FailureKind { 948341825Sdim /// Too many initializers provided for a reference. 949212795Sdim FK_TooManyInitsForReference, 950341825Sdim 951341825Sdim /// Reference initialized from a parenthesized initializer list. 952321369Sdim FK_ParenthesizedListInitForReference, 953341825Sdim 954341825Sdim /// Array must be initialized with an initializer list. 955212795Sdim FK_ArrayNeedsInitList, 956341825Sdim 957341825Sdim /// Array must be initialized with an initializer list or a 958212795Sdim /// string literal. 959212795Sdim FK_ArrayNeedsInitListOrStringLiteral, 960341825Sdim 961341825Sdim /// Array must be initialized with an initializer list or a 962261991Sdim /// wide string literal. 963261991Sdim FK_ArrayNeedsInitListOrWideStringLiteral, 964341825Sdim 965341825Sdim /// Initializing a wide char array with narrow string literal. 966261991Sdim FK_NarrowStringIntoWideCharArray, 967341825Sdim 968341825Sdim /// Initializing char array with wide string literal. 969261991Sdim FK_WideStringIntoCharArray, 970341825Sdim 971341825Sdim /// Initializing wide char array with incompatible wide string 972261991Sdim /// literal. 973261991Sdim FK_IncompatWideStringIntoWideChar, 974341825Sdim 975341825Sdim /// Initializing char8_t array with plain string literal. 976341825Sdim FK_PlainStringIntoUTF8Char, 977341825Sdim 978341825Sdim /// Initializing char array with UTF-8 string literal. 979341825Sdim FK_UTF8StringIntoPlainChar, 980341825Sdim 981341825Sdim /// Array type mismatch. 982219077Sdim FK_ArrayTypeMismatch, 983341825Sdim 984341825Sdim /// Non-constant array initializer 985219077Sdim FK_NonConstantArrayInit, 986341825Sdim 987341825Sdim /// Cannot resolve the address of an overloaded function. 988212795Sdim FK_AddressOfOverloadFailed, 989341825Sdim 990341825Sdim /// Overloading due to reference initialization failed. 991212795Sdim FK_ReferenceInitOverloadFailed, 992341825Sdim 993341825Sdim /// Non-const lvalue reference binding to a temporary. 994212795Sdim FK_NonConstLValueReferenceBindingToTemporary, 995341825Sdim 996341825Sdim /// Non-const lvalue reference binding to a bit-field. 997314564Sdim FK_NonConstLValueReferenceBindingToBitfield, 998341825Sdim 999341825Sdim /// Non-const lvalue reference binding to a vector element. 1000314564Sdim FK_NonConstLValueReferenceBindingToVectorElement, 1001341825Sdim 1002341825Sdim /// Non-const lvalue reference binding to an lvalue of unrelated 1003212795Sdim /// type. 1004212795Sdim FK_NonConstLValueReferenceBindingToUnrelated, 1005341825Sdim 1006341825Sdim /// Rvalue reference binding to an lvalue. 1007212795Sdim FK_RValueReferenceBindingToLValue, 1008341825Sdim 1009341825Sdim /// Reference binding drops qualifiers. 1010212795Sdim FK_ReferenceInitDropsQualifiers, 1011341825Sdim 1012353358Sdim /// Reference with mismatching address space binding to temporary. 1013353358Sdim FK_ReferenceAddrspaceMismatchTemporary, 1014353358Sdim 1015341825Sdim /// Reference binding failed. 1016212795Sdim FK_ReferenceInitFailed, 1017341825Sdim 1018341825Sdim /// Implicit conversion failed. 1019212795Sdim FK_ConversionFailed, 1020341825Sdim 1021341825Sdim /// Implicit conversion failed. 1022221345Sdim FK_ConversionFromPropertyFailed, 1023341825Sdim 1024341825Sdim /// Too many initializers for scalar 1025212795Sdim FK_TooManyInitsForScalar, 1026341825Sdim 1027341825Sdim /// Scalar initialized from a parenthesized initializer list. 1028321369Sdim FK_ParenthesizedListInitForScalar, 1029341825Sdim 1030341825Sdim /// Reference initialization from an initializer list 1031212795Sdim FK_ReferenceBindingToInitList, 1032341825Sdim 1033341825Sdim /// Initialization of some unused destination type with an 1034212795Sdim /// initializer list. 1035212795Sdim FK_InitListBadDestinationType, 1036341825Sdim 1037341825Sdim /// Overloading for a user-defined conversion failed. 1038212795Sdim FK_UserConversionOverloadFailed, 1039341825Sdim 1040341825Sdim /// Overloading for initialization by constructor failed. 1041212795Sdim FK_ConstructorOverloadFailed, 1042341825Sdim 1043341825Sdim /// Overloading for list-initialization by constructor failed. 1044234353Sdim FK_ListConstructorOverloadFailed, 1045341825Sdim 1046341825Sdim /// Default-initialization of a 'const' object. 1047212795Sdim FK_DefaultInitOfConst, 1048341825Sdim 1049341825Sdim /// Initialization of an incomplete type. 1050226633Sdim FK_Incomplete, 1051341825Sdim 1052341825Sdim /// Variable-length array must not have an initializer. 1053234353Sdim FK_VariableLengthArrayHasInitializer, 1054341825Sdim 1055341825Sdim /// List initialization failed at some point. 1056234353Sdim FK_ListInitializationFailed, 1057341825Sdim 1058341825Sdim /// Initializer has a placeholder type which cannot be 1059234353Sdim /// resolved by initialization. 1060234353Sdim FK_PlaceholderType, 1061341825Sdim 1062341825Sdim /// Trying to take the address of a function that doesn't support 1063296417Sdim /// having its address taken. 1064296417Sdim FK_AddressOfUnaddressableFunction, 1065341825Sdim 1066341825Sdim /// List-copy-initialization chose an explicit constructor. 1067321369Sdim FK_ExplicitConstructor, 1068212795Sdim }; 1069341825Sdim 1070212795Sdimprivate: 1071341825Sdim /// The reason why initialization failed. 1072212795Sdim FailureKind Failure; 1073212795Sdim 1074341825Sdim /// The failed result of overload resolution. 1075212795Sdim OverloadingResult FailedOverloadResult; 1076341825Sdim 1077341825Sdim /// The candidate set created when initialization failed. 1078212795Sdim OverloadCandidateSet FailedCandidateSet; 1079212795Sdim 1080341825Sdim /// The incomplete type that caused a failure. 1081234353Sdim QualType FailedIncompleteType; 1082288943Sdim 1083341825Sdim /// The fixit that needs to be applied to make this initialization 1084288943Sdim /// succeed. 1085288943Sdim std::string ZeroInitializationFixit; 1086288943Sdim SourceLocation ZeroInitializationFixitLoc; 1087288943Sdim 1088288943Sdimpublic: 1089341825Sdim /// Call for initializations are invalid but that would be valid 1090288943Sdim /// zero initialzations if Fixit was applied. 1091288943Sdim void SetZeroInitializationFixit(const std::string& Fixit, SourceLocation L) { 1092288943Sdim ZeroInitializationFixit = Fixit; 1093288943Sdim ZeroInitializationFixitLoc = L; 1094288943Sdim } 1095288943Sdim 1096288943Sdimprivate: 1097341825Sdim /// Prints a follow-up note that highlights the location of 1098212795Sdim /// the initialized entity, if it's remote. 1099212795Sdim void PrintInitLocationNote(Sema &S, const InitializedEntity &Entity); 1100212795Sdim 1101212795Sdimpublic: 1102341825Sdim /// Try to perform initialization of the given entity, creating a 1103212795Sdim /// record of the steps required to perform the initialization. 1104212795Sdim /// 1105212795Sdim /// The generated initialization sequence will either contain enough 1106341825Sdim /// information to diagnose 1107212795Sdim /// 1108212795Sdim /// \param S the semantic analysis object. 1109212795Sdim /// 1110212795Sdim /// \param Entity the entity being initialized. 1111212795Sdim /// 1112212795Sdim /// \param Kind the kind of initialization being performed. 1113212795Sdim /// 1114212795Sdim /// \param Args the argument(s) provided for initialization. 1115261991Sdim /// 1116276479Sdim /// \param TopLevelOfInitList true if we are initializing from an expression 1117276479Sdim /// at the top level inside an initializer list. This disallows 1118276479Sdim /// narrowing conversions in C++11 onwards. 1119309124Sdim /// \param TreatUnavailableAsInvalid true if we want to treat unavailable 1120309124Sdim /// as invalid. 1121341825Sdim InitializationSequence(Sema &S, 1122212795Sdim const InitializedEntity &Entity, 1123212795Sdim const InitializationKind &Kind, 1124261991Sdim MultiExprArg Args, 1125309124Sdim bool TopLevelOfInitList = false, 1126309124Sdim bool TreatUnavailableAsInvalid = true); 1127261991Sdim void InitializeFrom(Sema &S, const InitializedEntity &Entity, 1128261991Sdim const InitializationKind &Kind, MultiExprArg Args, 1129309124Sdim bool TopLevelOfInitList, bool TreatUnavailableAsInvalid); 1130261991Sdim 1131212795Sdim ~InitializationSequence(); 1132341825Sdim 1133341825Sdim /// Perform the actual initialization of the given entity based on 1134212795Sdim /// the computed initialization sequence. 1135212795Sdim /// 1136212795Sdim /// \param S the semantic analysis object. 1137212795Sdim /// 1138212795Sdim /// \param Entity the entity being initialized. 1139212795Sdim /// 1140212795Sdim /// \param Kind the kind of initialization being performed. 1141212795Sdim /// 1142212795Sdim /// \param Args the argument(s) provided for initialization, ownership of 1143221345Sdim /// which is transferred into the routine. 1144212795Sdim /// 1145212795Sdim /// \param ResultType if non-NULL, will be set to the type of the 1146212795Sdim /// initialized object, which is the type of the declaration in most 1147212795Sdim /// cases. However, when the initialized object is a variable of 1148212795Sdim /// incomplete array type and the initializer is an initializer 1149212795Sdim /// list, this type will be set to the completed array type. 1150212795Sdim /// 1151212795Sdim /// \returns an expression that performs the actual object initialization, if 1152212795Sdim /// the initialization is well-formed. Otherwise, emits diagnostics 1153212795Sdim /// and returns an invalid expression. 1154212795Sdim ExprResult Perform(Sema &S, 1155212795Sdim const InitializedEntity &Entity, 1156212795Sdim const InitializationKind &Kind, 1157212795Sdim MultiExprArg Args, 1158276479Sdim QualType *ResultType = nullptr); 1159341825Sdim 1160341825Sdim /// Diagnose an potentially-invalid initialization sequence. 1161212795Sdim /// 1162341825Sdim /// \returns true if the initialization sequence was ill-formed, 1163212795Sdim /// false otherwise. 1164341825Sdim bool Diagnose(Sema &S, 1165212795Sdim const InitializedEntity &Entity, 1166212795Sdim const InitializationKind &Kind, 1167251662Sdim ArrayRef<Expr *> Args); 1168341825Sdim 1169341825Sdim /// Determine the kind of initialization sequence computed. 1170212795Sdim enum SequenceKind getKind() const { return SequenceKind; } 1171341825Sdim 1172341825Sdim /// Set the kind of sequence computed. 1173212795Sdim void setSequenceKind(enum SequenceKind SK) { SequenceKind = SK; } 1174341825Sdim 1175341825Sdim /// Determine whether the initialization sequence is valid. 1176288943Sdim explicit operator bool() const { return !Failed(); } 1177223017Sdim 1178341825Sdim /// Determine whether the initialization sequence is invalid. 1179223017Sdim bool Failed() const { return SequenceKind == FailedSequence; } 1180261991Sdim 1181341825Sdim using step_iterator = SmallVectorImpl<Step>::const_iterator; 1182341825Sdim 1183212795Sdim step_iterator step_begin() const { return Steps.begin(); } 1184212795Sdim step_iterator step_end() const { return Steps.end(); } 1185212795Sdim 1186341825Sdim using step_range = llvm::iterator_range<step_iterator>; 1187341825Sdim 1188309124Sdim step_range steps() const { return {step_begin(), step_end()}; } 1189309124Sdim 1190341825Sdim /// Determine whether this initialization is a direct reference 1191212795Sdim /// binding (C++ [dcl.init.ref]). 1192212795Sdim bool isDirectReferenceBinding() const; 1193341825Sdim 1194341825Sdim /// Determine whether this initialization failed due to an ambiguity. 1195212795Sdim bool isAmbiguous() const; 1196341825Sdim 1197341825Sdim /// Determine whether this initialization is direct call to a 1198212795Sdim /// constructor. 1199212795Sdim bool isConstructorInitialization() const; 1200226633Sdim 1201341825Sdim /// Returns whether the last step in this initialization sequence is a 1202226633Sdim /// narrowing conversion, defined by C++0x [dcl.init.list]p7. 1203226633Sdim /// 1204226633Sdim /// If this function returns true, *isInitializerConstant will be set to 1205226633Sdim /// describe whether *Initializer was a constant expression. If 1206226633Sdim /// *isInitializerConstant is set to true, *ConstantValue will be set to the 1207226633Sdim /// evaluated value of *Initializer. 1208226633Sdim bool endsWithNarrowing(ASTContext &Ctx, const Expr *Initializer, 1209226633Sdim bool *isInitializerConstant, 1210226633Sdim APValue *ConstantValue) const; 1211226633Sdim 1212341825Sdim /// Add a new step in the initialization that resolves the address 1213212795Sdim /// of an overloaded function to a specific function declaration. 1214212795Sdim /// 1215212795Sdim /// \param Function the function to which the overloaded function reference 1216212795Sdim /// resolves. 1217212795Sdim void AddAddressOverloadResolutionStep(FunctionDecl *Function, 1218234353Sdim DeclAccessPair Found, 1219234353Sdim bool HadMultipleCandidates); 1220234353Sdim 1221341825Sdim /// Add a new step in the initialization that performs a derived-to- 1222212795Sdim /// base cast. 1223212795Sdim /// 1224212795Sdim /// \param BaseType the base type to which we will be casting. 1225212795Sdim /// 1226239462Sdim /// \param Category Indicates whether the result will be treated as an 1227239462Sdim /// rvalue, an xvalue, or an lvalue. 1228212795Sdim void AddDerivedToBaseCastStep(QualType BaseType, 1229212795Sdim ExprValueKind Category); 1230341825Sdim 1231341825Sdim /// Add a new step binding a reference to an object. 1232212795Sdim /// 1233212795Sdim /// \param BindingTemporary True if we are binding a reference to a temporary 1234212795Sdim /// object (thereby extending its lifetime); false if we are binding to an 1235212795Sdim /// lvalue or an lvalue treated as an rvalue. 1236212795Sdim void AddReferenceBindingStep(QualType T, bool BindingTemporary); 1237212795Sdim 1238341825Sdim /// Add a new step that makes an extraneous copy of the input 1239212795Sdim /// to a temporary of the same class type. 1240212795Sdim /// 1241212795Sdim /// This extraneous copy only occurs during reference binding in 1242212795Sdim /// C++98/03, where we are permitted (but not required) to introduce 1243212795Sdim /// an extra copy. At a bare minimum, we must check that we could 1244212795Sdim /// call the copy constructor, and produce a diagnostic if the copy 1245212795Sdim /// constructor is inaccessible or no copy constructor matches. 1246212795Sdim // 1247212795Sdim /// \param T The type of the temporary being created. 1248212795Sdim void AddExtraneousCopyToTemporary(QualType T); 1249212795Sdim 1250341825Sdim /// Add a new step that makes a copy of the input to an object of 1251314564Sdim /// the given type, as the final step in class copy-initialization. 1252314564Sdim void AddFinalCopy(QualType T); 1253314564Sdim 1254341825Sdim /// Add a new step invoking a conversion function, which is either 1255212795Sdim /// a constructor or a conversion function. 1256212795Sdim void AddUserConversionStep(FunctionDecl *Function, 1257212795Sdim DeclAccessPair FoundDecl, 1258234353Sdim QualType T, 1259234353Sdim bool HadMultipleCandidates); 1260234353Sdim 1261341825Sdim /// Add a new step that performs a qualification conversion to the 1262212795Sdim /// given type. 1263212795Sdim void AddQualificationConversionStep(QualType Ty, 1264212795Sdim ExprValueKind Category); 1265276479Sdim 1266341825Sdim /// Add a new step that performs conversion from non-atomic to atomic 1267276479Sdim /// type. 1268276479Sdim void AddAtomicConversionStep(QualType Ty); 1269276479Sdim 1270341825Sdim /// Add a new step that applies an implicit conversion sequence. 1271212795Sdim void AddConversionSequenceStep(const ImplicitConversionSequence &ICS, 1272261991Sdim QualType T, bool TopLevelOfInitList = false); 1273212795Sdim 1274341825Sdim /// Add a list-initialization step. 1275212795Sdim void AddListInitializationStep(QualType T); 1276212795Sdim 1277341825Sdim /// Add a constructor-initialization step. 1278234353Sdim /// 1279243830Sdim /// \param FromInitList The constructor call is syntactically an initializer 1280234353Sdim /// list. 1281243830Sdim /// \param AsInitList The constructor is called as an init list constructor. 1282309124Sdim void AddConstructorInitializationStep(DeclAccessPair FoundDecl, 1283309124Sdim CXXConstructorDecl *Constructor, 1284234353Sdim QualType T, 1285234353Sdim bool HadMultipleCandidates, 1286234353Sdim bool FromInitList, bool AsInitList); 1287212795Sdim 1288341825Sdim /// Add a zero-initialization step. 1289212795Sdim void AddZeroInitializationStep(QualType T); 1290234353Sdim 1291341825Sdim /// Add a C assignment step. 1292212795Sdim // 1293212795Sdim // FIXME: It isn't clear whether this should ever be needed; 1294212795Sdim // ideally, we would handle everything needed in C in the common 1295212795Sdim // path. However, that isn't the case yet. 1296212795Sdim void AddCAssignmentStep(QualType T); 1297212795Sdim 1298341825Sdim /// Add a string init step. 1299212795Sdim void AddStringInitStep(QualType T); 1300212795Sdim 1301341825Sdim /// Add an Objective-C object conversion step, which is 1302212795Sdim /// always a no-op. 1303212795Sdim void AddObjCObjectConversionStep(QualType T); 1304212795Sdim 1305341825Sdim /// Add an array initialization loop step. 1306314564Sdim void AddArrayInitLoopStep(QualType T, QualType EltTy); 1307314564Sdim 1308341825Sdim /// Add an array initialization step. 1309314564Sdim void AddArrayInitStep(QualType T, bool IsGNUExtension); 1310219077Sdim 1311341825Sdim /// Add a parenthesized array initialization step. 1312234353Sdim void AddParenthesizedArrayInitStep(QualType T); 1313234353Sdim 1314341825Sdim /// Add a step to pass an object by indirect copy-restore. 1315224145Sdim void AddPassByIndirectCopyRestoreStep(QualType T, bool shouldCopy); 1316224145Sdim 1317341825Sdim /// Add a step to "produce" an Objective-C object (by 1318224145Sdim /// retaining it). 1319224145Sdim void AddProduceObjCObjectStep(QualType T); 1320224145Sdim 1321341825Sdim /// Add a step to construct a std::initializer_list object from an 1322234353Sdim /// initializer list. 1323234353Sdim void AddStdInitializerListConstructionStep(QualType T); 1324234353Sdim 1325341825Sdim /// Add a step to initialize an OpenCL sampler from an integer 1326249423Sdim /// constant. 1327249423Sdim void AddOCLSamplerInitStep(QualType T); 1328249423Sdim 1329344779Sdim /// Add a step to initialzie an OpenCL opaque type (event_t, queue_t, etc.) 1330344779Sdim /// from a zero constant. 1331344779Sdim void AddOCLZeroOpaqueTypeStep(QualType T); 1332249423Sdim 1333344779Sdim /// Add a step to initialize by zero types defined in the 1334344779Sdim /// cl_intel_device_side_avc_motion_estimation OpenCL extension 1335344779Sdim void AddOCLIntelSubgroupAVCZeroInitStep(QualType T); 1336314564Sdim 1337341825Sdim /// Add steps to unwrap a initializer list for a reference around a 1338234353Sdim /// single element and rewrap it at the end. 1339234353Sdim void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic); 1340234353Sdim 1341341825Sdim /// Note that this initialization sequence failed. 1342212795Sdim void SetFailed(FailureKind Failure) { 1343212795Sdim SequenceKind = FailedSequence; 1344212795Sdim this->Failure = Failure; 1345234353Sdim assert((Failure != FK_Incomplete || !FailedIncompleteType.isNull()) && 1346234353Sdim "Incomplete type failure requires a type!"); 1347212795Sdim } 1348341825Sdim 1349341825Sdim /// Note that this initialization sequence failed due to failed 1350212795Sdim /// overload resolution. 1351212795Sdim void SetOverloadFailure(FailureKind Failure, OverloadingResult Result); 1352341825Sdim 1353341825Sdim /// Retrieve a reference to the candidate set when overload 1354212795Sdim /// resolution fails. 1355212795Sdim OverloadCandidateSet &getFailedCandidateSet() { 1356212795Sdim return FailedCandidateSet; 1357212795Sdim } 1358212795Sdim 1359341825Sdim /// Get the overloading result, for when the initialization 1360218893Sdim /// sequence failed due to a bad overload. 1361218893Sdim OverloadingResult getFailedOverloadResult() const { 1362218893Sdim return FailedOverloadResult; 1363218893Sdim } 1364218893Sdim 1365341825Sdim /// Note that this initialization sequence failed due to an 1366234353Sdim /// incomplete type. 1367234353Sdim void setIncompleteTypeFailure(QualType IncompleteType) { 1368234353Sdim FailedIncompleteType = IncompleteType; 1369234353Sdim SetFailed(FK_Incomplete); 1370234353Sdim } 1371234353Sdim 1372341825Sdim /// Determine why initialization failed. 1373212795Sdim FailureKind getFailureKind() const { 1374223017Sdim assert(Failed() && "Not an initialization failure!"); 1375212795Sdim return Failure; 1376212795Sdim } 1377218893Sdim 1378341825Sdim /// Dump a representation of this initialization sequence to 1379212795Sdim /// the given stream, for debugging purposes. 1380226633Sdim void dump(raw_ostream &OS) const; 1381341825Sdim 1382341825Sdim /// Dump a representation of this initialization sequence to 1383212795Sdim /// standard error, for debugging purposes. 1384212795Sdim void dump() const; 1385212795Sdim}; 1386212795Sdim 1387341825Sdim} // namespace clang 1388341825Sdim 1389212795Sdim#endif // LLVM_CLANG_SEMA_INITIALIZATION_H 1390