contrib/llvm/tools/clang/include/clang/Sema/Initialization.h

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