Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- Initialization.h - Semantic Analysis for Initializers ----*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file provides supporting data types for initialization of objects.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_SEMA_INITIALIZATION_H

#define LLVM_CLANG_SEMA_INITIALIZATION_H

#include "clang/AST/ASTContext.h"

#include "clang/AST/Attr.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclAccessPair.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/Expr.h"

#include "clang/AST/Type.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Specifiers.h"

#include "clang/Sema/Overload.h"

#include "clang/Sema/Ownership.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Support/Casting.h"

#include <cassert>

#include <cstdint>

#include <string>

namespace clang {

class CXXBaseSpecifier;

class CXXConstructorDecl;

class ObjCMethodDecl;

class Sema;

/// Describes an entity that is being initialized.

class alignas(8) InitializedEntity {

public:

  /// Specifies the kind of entity being initialized.

  enum EntityKind {

    /// The entity being initialized is a variable.

    EK_Variable,

    /// The entity being initialized is a function parameter.

    EK_Parameter,

    /// The entity being initialized is a non-type template parameter.

    EK_TemplateParameter,

    /// The entity being initialized is the result of a function call.

    EK_Result,

    /// The entity being initialized is the result of a statement expression.

    EK_StmtExprResult,

    /// The entity being initialized is an exception object that

    /// is being thrown.

    EK_Exception,

    /// The entity being initialized is a non-static data member

    /// subobject.

    EK_Member,

    /// The entity being initialized is an element of an array.

    EK_ArrayElement,

    /// The entity being initialized is an object (or array of

    /// objects) allocated via new.

    EK_New,

    /// The entity being initialized is a temporary object.

    EK_Temporary,

    /// The entity being initialized is a base member subobject.

    EK_Base,

    /// The initialization is being done by a delegating constructor.

    EK_Delegating,

    /// The entity being initialized is an element of a vector.

    /// or vector.

    EK_VectorElement,

    /// The entity being initialized is a field of block descriptor for

    /// the copied-in c++ object.

    EK_BlockElement,

    /// The entity being initialized is a field of block descriptor for the

    /// copied-in lambda object that's used in the lambda to block conversion.

    EK_LambdaToBlockConversionBlockElement,

    /// The entity being initialized is the real or imaginary part of a

    /// complex number.

    EK_ComplexElement,

    /// The entity being initialized is the field that captures a

    /// variable in a lambda.

    EK_LambdaCapture,

    /// The entity being initialized is the initializer for a compound

    /// literal.

    EK_CompoundLiteralInit,

    /// The entity being implicitly initialized back to the formal

    /// result type.

    EK_RelatedResult,

    /// The entity being initialized is a function parameter; function

    /// is member of group of audited CF APIs.

    EK_Parameter_CF_Audited,

    /// The entity being initialized is a structured binding of a

    /// decomposition declaration.

    EK_Binding,

    /// The entity being initialized is a non-static data member subobject of an

    /// object initialized via parenthesized aggregate initialization.

    EK_ParenAggInitMember,

    // Note: err_init_conversion_failed in DiagnosticSemaKinds.td uses this

    // enum as an index for its first %select.  When modifying this list,

    // that diagnostic text needs to be updated as well.

  };

private:

  /// The kind of entity being initialized.

  EntityKind Kind;

  /// If non-NULL, the parent entity in which this

  /// initialization occurs.

  const InitializedEntity *Parent = nullptr;

  /// The type of the object or reference being initialized.

  QualType Type;

  /// The mangling number for the next reference temporary to be created.

  mutable unsigned ManglingNumber = 0;

  struct LN {

    /// When Kind == EK_Result, EK_Exception, EK_New, the

    /// location of the 'return', 'throw', or 'new' keyword,

    /// respectively. When Kind == EK_Temporary, the location where

    /// the temporary is being created.

    SourceLocation Location;

    /// Whether the entity being initialized may end up using the

    /// named return value optimization (NRVO).

    bool NRVO;

  };

  struct VD {

    /// The VarDecl, FieldDecl, or BindingDecl being initialized.

    ValueDecl *VariableOrMember;

    /// When Kind == EK_Member, whether this is an implicit member

    /// initialization in a copy or move constructor. These can perform array

    /// copies.

    bool IsImplicitFieldInit;

    /// When Kind == EK_Member, whether this is the initial initialization

    /// check for a default member initializer.

    bool IsDefaultMemberInit;

  };

  struct C {

    /// The name of the variable being captured by an EK_LambdaCapture.

    IdentifierInfo *VarID;

    /// The source location at which the capture occurs.

    SourceLocation Location;

  };

  union {

    /// When Kind == EK_Variable, EK_Member, EK_Binding, or

    /// EK_TemplateParameter, the variable, binding, or template parameter.

    VD Variable;

    /// When Kind == EK_RelatedResult, the ObjectiveC method where

    /// result type was implicitly changed to accommodate ARC semantics.

    ObjCMethodDecl *MethodDecl;

    /// When Kind == EK_Parameter, the ParmVarDecl, with the

    /// integer indicating whether the parameter is "consumed".

    llvm::PointerIntPair<ParmVarDecl *, 1> Parameter;

    /// When Kind == EK_Temporary or EK_CompoundLiteralInit, the type

    /// source information for the temporary.

    TypeSourceInfo *TypeInfo;

    struct LN LocAndNRVO;

    /// When Kind == EK_Base, the base specifier that provides the

    /// base class. The integer specifies whether the base is an inherited

    /// virtual base.

    llvm::PointerIntPair<const CXXBaseSpecifier *, 1> Base;

    /// When Kind == EK_ArrayElement, EK_VectorElement, or

    /// EK_ComplexElement, the index of the array or vector element being

    /// initialized.

    unsigned Index;

    struct C Capture;

  };

  InitializedEntity() {};

  /// Create the initialization entity for a variable.

  InitializedEntity(VarDecl *Var, EntityKind EK = EK_Variable)

      : Kind(EK), Type(Var->getType()), Variable{Var, false, false} {}

  /// Create the initialization entity for the result of a

  /// function, throwing an object, performing an explicit cast, or

  /// initializing a parameter for which there is no declaration.

  InitializedEntity(EntityKind Kind, SourceLocation Loc, QualType Type,

                    bool NRVO = false)

      : Kind(Kind), Type(Type) {

    new (&LocAndNRVO) LN;

    LocAndNRVO.Location = Loc;

    LocAndNRVO.NRVO = NRVO;

  }

  /// Create the initialization entity for a member subobject.

  InitializedEntity(FieldDecl *Member, const InitializedEntity *Parent,

                    bool Implicit, bool DefaultMemberInit,

                    bool IsParenAggInit = false)

      : Kind(IsParenAggInit ? EK_ParenAggInitMember : EK_Member),

        Parent(Parent), Type(Member->getType()),

        Variable{Member, Implicit, DefaultMemberInit} {}

  /// Create the initialization entity for an array element.

  InitializedEntity(ASTContext &Context, unsigned Index,

                    const InitializedEntity &Parent);

  /// Create the initialization entity for a lambda capture.

  InitializedEntity(IdentifierInfo *VarID, QualType FieldType, SourceLocation Loc)

      : Kind(EK_LambdaCapture), Type(FieldType) {

    new (&Capture) C;

    Capture.VarID = VarID;

    Capture.Location = Loc;

  }

public:

  /// Create the initialization entity for a variable.

  static InitializedEntity InitializeVariable(VarDecl *Var) {

    return InitializedEntity(Var);

  }

  /// Create the initialization entity for a parameter.

  static InitializedEntity InitializeParameter(ASTContext &Context,

                                               ParmVarDecl *Parm) {

    return InitializeParameter(Context, Parm, Parm->getType());

  }

  /// Create the initialization entity for a parameter, but use

  /// another type.

  static InitializedEntity

  InitializeParameter(ASTContext &Context, ParmVarDecl *Parm, QualType Type) {

    bool Consumed = (Context.getLangOpts().ObjCAutoRefCount &&

                     Parm->hasAttr<NSConsumedAttr>());

    InitializedEntity Entity;

    Entity.Kind = EK_Parameter;

    Entity.Type =

      Context.getVariableArrayDecayedType(Type.getUnqualifiedType());

    Entity.Parent = nullptr;

    Entity.Parameter = {Parm, Consumed};

    return Entity;

  }

  /// Create the initialization entity for a parameter that is

  /// only known by its type.

  static InitializedEntity InitializeParameter(ASTContext &Context,

                                               QualType Type,

                                               bool Consumed) {

    InitializedEntity Entity;

    Entity.Kind = EK_Parameter;

    Entity.Type = Context.getVariableArrayDecayedType(Type);

    Entity.Parent = nullptr;

    Entity.Parameter = {nullptr, Consumed};

    return Entity;

  }

  /// Create the initialization entity for a template parameter.

  static InitializedEntity

  InitializeTemplateParameter(QualType T, NonTypeTemplateParmDecl *Param) {

    InitializedEntity Entity;

    Entity.Kind = EK_TemplateParameter;

    Entity.Type = T;

    Entity.Parent = nullptr;

    Entity.Variable = {Param, false, false};

    return Entity;

  }

  /// Create the initialization entity for the result of a function.

  static InitializedEntity InitializeResult(SourceLocation ReturnLoc,

                                            QualType Type) {

    return InitializedEntity(EK_Result, ReturnLoc, Type);

  }

  static InitializedEntity InitializeStmtExprResult(SourceLocation ReturnLoc,

                                            QualType Type) {

    return InitializedEntity(EK_StmtExprResult, ReturnLoc, Type);

  }

  static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc,

                                           QualType Type) {

    return InitializedEntity(EK_BlockElement, BlockVarLoc, Type);

  }

  static InitializedEntity InitializeLambdaToBlock(SourceLocation BlockVarLoc,

                                                   QualType Type) {

    return InitializedEntity(EK_LambdaToBlockConversionBlockElement,

                             BlockVarLoc, Type);

  }

  /// Create the initialization entity for an exception object.

  static InitializedEntity InitializeException(SourceLocation ThrowLoc,

                                               QualType Type) {

    return InitializedEntity(EK_Exception, ThrowLoc, Type);

  }

  /// Create the initialization entity for an object allocated via new.

  static InitializedEntity InitializeNew(SourceLocation NewLoc, QualType Type) {

    return InitializedEntity(EK_New, NewLoc, Type);

  }

  /// Create the initialization entity for a temporary.

  static InitializedEntity InitializeTemporary(QualType Type) {

    return InitializeTemporary(nullptr, Type);

  }

  /// Create the initialization entity for a temporary.

  static InitializedEntity InitializeTemporary(ASTContext &Context,

                                               TypeSourceInfo *TypeInfo) {

    QualType Type = TypeInfo->getType();

    if (Context.getLangOpts().OpenCLCPlusPlus) {

      assert(!Type.hasAddressSpace() && "Temporary already has address space!");

      Type = Context.getAddrSpaceQualType(Type, LangAS::opencl_private);

    }

    return InitializeTemporary(TypeInfo, Type);

  }

  /// Create the initialization entity for a temporary.

  static InitializedEntity InitializeTemporary(TypeSourceInfo *TypeInfo,

                                               QualType Type) {

    InitializedEntity Result(EK_Temporary, SourceLocation(), Type);

    Result.TypeInfo = TypeInfo;

    return Result;

  }

  /// Create the initialization entity for a related result.

  static InitializedEntity InitializeRelatedResult(ObjCMethodDecl *MD,

                                                   QualType Type) {

    InitializedEntity Result(EK_RelatedResult, SourceLocation(), Type);

    Result.MethodDecl = MD;

    return Result;

  }

  /// Create the initialization entity for a base class subobject.

  static InitializedEntity

  InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base,

                 bool IsInheritedVirtualBase,

                 const InitializedEntity *Parent = nullptr);

  /// Create the initialization entity for a delegated constructor.

  static InitializedEntity InitializeDelegation(QualType Type) {

    return InitializedEntity(EK_Delegating, SourceLocation(), Type);

  }

  /// Create the initialization entity for a member subobject.

  static InitializedEntity

  InitializeMember(FieldDecl *Member,

                   const InitializedEntity *Parent = nullptr,

                   bool Implicit = false) {

    return InitializedEntity(Member, Parent, Implicit, false);

  }

  /// Create the initialization entity for a member subobject.

  static InitializedEntity

  InitializeMember(IndirectFieldDecl *Member,

                   const InitializedEntity *Parent = nullptr,

                   bool Implicit = false) {

    return InitializedEntity(Member->getAnonField(), Parent, Implicit, false);

  }

  /// Create the initialization entity for a member subobject initialized via

  /// parenthesized aggregate init.

  static InitializedEntity InitializeMemberFromParenAggInit(FieldDecl *Member) {

    return InitializedEntity(Member, /*Parent=*/nullptr, /*Implicit=*/false,

                             /*DefaultMemberInit=*/false,

                             /*IsParenAggInit=*/true);

  }

  /// Create the initialization entity for a default member initializer.

  static InitializedEntity

  InitializeMemberFromDefaultMemberInitializer(FieldDecl *Member) {

    return InitializedEntity(Member, nullptr, false, true);

  }

  /// Create the initialization entity for an array element.

  static InitializedEntity InitializeElement(ASTContext &Context,

                                             unsigned Index,

                                             const InitializedEntity &Parent) {

    return InitializedEntity(Context, Index, Parent);

  }

  /// Create the initialization entity for a structured binding.

  static InitializedEntity InitializeBinding(VarDecl *Binding) {

    return InitializedEntity(Binding, EK_Binding);

  }

  /// Create the initialization entity for a lambda capture.

  ///

  /// \p VarID The name of the entity being captured, or nullptr for 'this'.

  static InitializedEntity InitializeLambdaCapture(IdentifierInfo *VarID,

                                                   QualType FieldType,

                                                   SourceLocation Loc) {

    return InitializedEntity(VarID, FieldType, Loc);

  }

  /// Create the entity for a compound literal initializer.

  static InitializedEntity InitializeCompoundLiteralInit(TypeSourceInfo *TSI) {

    InitializedEntity Result(EK_CompoundLiteralInit, SourceLocation(),

                             TSI->getType());

    Result.TypeInfo = TSI;

    return Result;

  }

  /// Determine the kind of initialization.

  EntityKind getKind() const { return Kind; }

  /// Retrieve the parent of the entity being initialized, when

  /// the initialization itself is occurring within the context of a

  /// larger initialization.

  const InitializedEntity *getParent() const { return Parent; }

  /// Retrieve type being initialized.

  QualType getType() const { return Type; }

  /// Retrieve complete type-source information for the object being

  /// constructed, if known.

  TypeSourceInfo *getTypeSourceInfo() const {

    if (Kind == EK_Temporary || Kind == EK_CompoundLiteralInit)

      return TypeInfo;

    return nullptr;

  }

  /// Retrieve the name of the entity being initialized.

  DeclarationName getName() const;

  /// Retrieve the variable, parameter, or field being

  /// initialized.

  ValueDecl *getDecl() const;

  /// Retrieve the ObjectiveC method being initialized.

  ObjCMethodDecl *getMethodDecl() const { return MethodDecl; }

  /// Determine whether this initialization allows the named return

  /// value optimization, which also applies to thrown objects.

  bool allowsNRVO() const;

  bool isParameterKind() const {

    return (getKind() == EK_Parameter  ||

            getKind() == EK_Parameter_CF_Audited);

  }

  bool isParamOrTemplateParamKind() const {

    return isParameterKind() || getKind() == EK_TemplateParameter;

  }

  /// Determine whether this initialization consumes the

  /// parameter.

  bool isParameterConsumed() const {

    assert(isParameterKind() && "Not a parameter");

    return Parameter.getInt();

  }

  /// Retrieve the base specifier.

  const CXXBaseSpecifier *getBaseSpecifier() const {

    assert(getKind() == EK_Base && "Not a base specifier");

    return Base.getPointer();

  }

  /// Return whether the base is an inherited virtual base.

  bool isInheritedVirtualBase() const {

    assert(getKind() == EK_Base && "Not a base specifier");

    return Base.getInt();

  }

  /// Determine whether this is an array new with an unknown bound.

  bool isVariableLengthArrayNew() const {

    return getKind() == EK_New && isa_and_nonnull<IncompleteArrayType>(

                                      getType()->getAsArrayTypeUnsafe());

  }

  /// Is this the implicit initialization of a member of a class from

  /// a defaulted constructor?

  bool isImplicitMemberInitializer() const {

    return getKind() == EK_Member && Variable.IsImplicitFieldInit;

  }

  /// Is this the default member initializer of a member (specified inside

  /// the class definition)?

  bool isDefaultMemberInitializer() const {

    return getKind() == EK_Member && Variable.IsDefaultMemberInit;

  }

  /// Determine the location of the 'return' keyword when initializing

  /// the result of a function call.

  SourceLocation getReturnLoc() const {

    assert(getKind() == EK_Result && "No 'return' location!");

    return LocAndNRVO.Location;

  }

  /// Determine the location of the 'throw' keyword when initializing

  /// an exception object.

  SourceLocation getThrowLoc() const {

    assert(getKind() == EK_Exception && "No 'throw' location!");

    return LocAndNRVO.Location;

  }

  /// If this is an array, vector, or complex number element, get the

  /// element's index.

  unsigned getElementIndex() const {

    assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement ||

           getKind() == EK_ComplexElement);

    return Index;

  }

  /// If this is already the initializer for an array or vector

  /// element, sets the element index.

  void setElementIndex(unsigned Index) {

    assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement ||

           getKind() == EK_ComplexElement);

    this->Index = Index;

  }

  /// For a lambda capture, return the capture's name.

  StringRef getCapturedVarName() const {

    assert(getKind() == EK_LambdaCapture && "Not a lambda capture!");

    return Capture.VarID ? Capture.VarID->getName() : "this";

  }

  /// Determine the location of the capture when initializing

  /// field from a captured variable in a lambda.

  SourceLocation getCaptureLoc() const {

    assert(getKind() == EK_LambdaCapture && "Not a lambda capture!");

    return Capture.Location;

  }

  void setParameterCFAudited() {

    Kind = EK_Parameter_CF_Audited;

  }

  unsigned allocateManglingNumber() const { return ++ManglingNumber; }

  /// Dump a representation of the initialized entity to standard error,

  /// for debugging purposes.

  void dump() const;

private:

  unsigned dumpImpl(raw_ostream &OS) const;

};

/// Describes the kind of initialization being performed, along with

/// location information for tokens related to the initialization (equal sign,

/// parentheses).

class InitializationKind {

public:

  /// The kind of initialization being performed.

  enum InitKind {

    /// Direct initialization

    IK_Direct,

    /// Direct list-initialization

    IK_DirectList,

    /// Copy initialization

    IK_Copy,

    /// Default initialization

    IK_Default,

    /// Value initialization

    IK_Value

  };

private:

  /// The context of the initialization.

  enum InitContext {

    /// Normal context

    IC_Normal,

    /// Normal context, but allows explicit conversion functionss

    IC_ExplicitConvs,

    /// Implicit context (value initialization)

    IC_Implicit,

    /// Static cast context

    IC_StaticCast,

    /// C-style cast context

    IC_CStyleCast,

    /// Functional cast context

    IC_FunctionalCast

  };

  /// The kind of initialization being performed.

  InitKind Kind : 8;

  /// The context of the initialization.

  InitContext Context : 8;

  /// The source locations involved in the initialization.

  SourceLocation Locations[3];

  InitializationKind(InitKind Kind, InitContext Context, SourceLocation Loc1,

                     SourceLocation Loc2, SourceLocation Loc3)

      : Kind(Kind), Context(Context) {

    Locations[0] = Loc1;

    Locations[1] = Loc2;

    Locations[2] = Loc3;

  }

public:

  /// Create a direct initialization.

  static InitializationKind CreateDirect(SourceLocation InitLoc,

                                         SourceLocation LParenLoc,

                                         SourceLocation RParenLoc) {

    return InitializationKind(IK_Direct, IC_Normal,

                              InitLoc, LParenLoc, RParenLoc);

  }

  static InitializationKind CreateDirectList(SourceLocation InitLoc) {

    return InitializationKind(IK_DirectList, IC_Normal, InitLoc, InitLoc,

                              InitLoc);

  }

  static InitializationKind CreateDirectList(SourceLocation InitLoc,

                                             SourceLocation LBraceLoc,

                                             SourceLocation RBraceLoc) {

    return InitializationKind(IK_DirectList, IC_Normal, InitLoc, LBraceLoc,

                              RBraceLoc);

  }

  /// Create a direct initialization due to a cast that isn't a C-style

  /// or functional cast.

  static InitializationKind CreateCast(SourceRange TypeRange) {

    return InitializationKind(IK_Direct, IC_StaticCast, TypeRange.getBegin(),

                              TypeRange.getBegin(), TypeRange.getEnd());

  }

  /// Create a direct initialization for a C-style cast.

  static InitializationKind CreateCStyleCast(SourceLocation StartLoc,

                                             SourceRange TypeRange,

                                             bool InitList) {

    // C++ cast syntax doesn't permit init lists, but C compound literals are

    // exactly that.

    return InitializationKind(InitList ? IK_DirectList : IK_Direct,

                              IC_CStyleCast, StartLoc, TypeRange.getBegin(),

                              TypeRange.getEnd());

  }

  /// Create a direct initialization for a functional cast.

  static InitializationKind CreateFunctionalCast(SourceRange TypeRange,

                                                 bool InitList) {

    return InitializationKind(InitList ? IK_DirectList : IK_Direct,

                              IC_FunctionalCast, TypeRange.getBegin(),

                              TypeRange.getBegin(), TypeRange.getEnd());

  }

  /// Create a copy initialization.

  static InitializationKind CreateCopy(SourceLocation InitLoc,

                                       SourceLocation EqualLoc,

                                       bool AllowExplicitConvs = false) {

    return InitializationKind(IK_Copy,

                              AllowExplicitConvs? IC_ExplicitConvs : IC_Normal,

                              InitLoc, EqualLoc, EqualLoc);

  }

  /// Create a default initialization.

  static InitializationKind CreateDefault(SourceLocation InitLoc) {

    return InitializationKind(IK_Default, IC_Normal, InitLoc, InitLoc, InitLoc);

  }

  /// Create a value initialization.

  static InitializationKind CreateValue(SourceLocation InitLoc,

                                        SourceLocation LParenLoc,

                                        SourceLocation RParenLoc,

                                        bool isImplicit = false) {

    return InitializationKind(IK_Value, isImplicit ? IC_Implicit : IC_Normal,

                              InitLoc, LParenLoc, RParenLoc);

  }

  /// Create an initialization from an initializer (which, for direct

  /// initialization from a parenthesized list, will be a ParenListExpr).

  static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit,

                                          Expr *Init) {

    if (!Init) return CreateDefault(Loc);

    if (!DirectInit)

      return CreateCopy(Loc, Init->getBeginLoc());

    if (isa<InitListExpr>(Init))

      return CreateDirectList(Loc, Init->getBeginLoc(), Init->getEndLoc());

    return CreateDirect(Loc, Init->getBeginLoc(), Init->getEndLoc());

  }

  /// Determine the initialization kind.

  InitKind getKind() const {

    return Kind;

  }

  /// Determine whether this initialization is an explicit cast.

  bool isExplicitCast() const {

    return Context >= IC_StaticCast;

  }

  /// Determine whether this initialization is a static cast.

  bool isStaticCast() const { return Context == IC_StaticCast; }

  /// Determine whether this initialization is a C-style cast.

  bool isCStyleOrFunctionalCast() const {

    return Context >= IC_CStyleCast;

  }

  /// Determine whether this is a C-style cast.

  bool isCStyleCast() const {

    return Context == IC_CStyleCast;

  }

  /// Determine whether this is a functional-style cast.

  bool isFunctionalCast() const {

    return Context == IC_FunctionalCast;

  }

  /// Determine whether this initialization is an implicit

  /// value-initialization, e.g., as occurs during aggregate

  /// initialization.

  bool isImplicitValueInit() const { return Context == IC_Implicit; }

  /// Retrieve the location at which initialization is occurring.

  SourceLocation getLocation() const { return Locations[0]; }

  /// Retrieve the source range that covers the initialization.

  SourceRange getRange() const {

    return SourceRange(Locations[0], Locations[2]);

  }

  /// Retrieve the location of the equal sign for copy initialization

  /// (if present).

  SourceLocation getEqualLoc() const {

    assert(Kind == IK_Copy && "Only copy initialization has an '='");

    return Locations[1];

  }

  bool isCopyInit() const { return Kind == IK_Copy; }

  /// Retrieve whether this initialization allows the use of explicit

  ///        constructors.

  bool AllowExplicit() const { return !isCopyInit(); }

  /// Retrieve whether this initialization allows the use of explicit

  /// conversion functions when binding a reference. If the reference is the

  /// first parameter in a copy or move constructor, such conversions are

  /// permitted even though we are performing copy-initialization.

  bool allowExplicitConversionFunctionsInRefBinding() const {

    return !isCopyInit() || Context == IC_ExplicitConvs;

  }

  /// Determine whether this initialization has a source range containing the

  /// locations of open and closing parentheses or braces.

  bool hasParenOrBraceRange() const {

    return Kind == IK_Direct || Kind == IK_Value || Kind == IK_DirectList;

  }

  /// Retrieve the source range containing the locations of the open

  /// and closing parentheses or braces for value, direct, and direct list

  /// initializations.

  SourceRange getParenOrBraceRange() const {

    assert(hasParenOrBraceRange() && "Only direct, value, and direct-list "

                                     "initialization have parentheses or "

                                     "braces");

    return SourceRange(Locations[1], Locations[2]);

  }

};

/// Describes the sequence of initializations required to initialize

/// a given object or reference with a set of arguments.

class InitializationSequence {

public:

  /// Describes the kind of initialization sequence computed.

  enum SequenceKind {

    /// A failed initialization sequence. The failure kind tells what

    /// happened.

    FailedSequence = 0,

    /// A dependent initialization, which could not be

    /// type-checked due to the presence of dependent types or

    /// dependently-typed expressions.

    DependentSequence,

    /// A normal sequence.

    NormalSequence

  };

  /// Describes the kind of a particular step in an initialization

  /// sequence.

  enum StepKind {

    /// Resolve the address of an overloaded function to a specific

    /// function declaration.

    SK_ResolveAddressOfOverloadedFunction,

    /// Perform a derived-to-base cast, producing an rvalue.

    SK_CastDerivedToBasePRValue,

    /// Perform a derived-to-base cast, producing an xvalue.

    SK_CastDerivedToBaseXValue,

    /// Perform a derived-to-base cast, producing an lvalue.

    SK_CastDerivedToBaseLValue,

    /// Reference binding to an lvalue.

    SK_BindReference,

    /// Reference binding to a temporary.

    SK_BindReferenceToTemporary,

    /// An optional copy of a temporary object to another

    /// temporary object, which is permitted (but not required) by

    /// C++98/03 but not C++0x.

    SK_ExtraneousCopyToTemporary,

    /// Direct-initialization from a reference-related object in the

    /// final stage of class copy-initialization.

    SK_FinalCopy,

    /// Perform a user-defined conversion, either via a conversion

    /// function or via a constructor.

    SK_UserConversion,

    /// Perform a qualification conversion, producing a prvalue.

    SK_QualificationConversionPRValue,

    /// Perform a qualification conversion, producing an xvalue.

    SK_QualificationConversionXValue,

    /// Perform a qualification conversion, producing an lvalue.

    SK_QualificationConversionLValue,

    /// Perform a function reference conversion, see [dcl.init.ref]p4.

    SK_FunctionReferenceConversion,

    /// Perform a conversion adding _Atomic to a type.

    SK_AtomicConversion,

    /// Perform an implicit conversion sequence.

    SK_ConversionSequence,

    /// Perform an implicit conversion sequence without narrowing.

    SK_ConversionSequenceNoNarrowing,

    /// Perform list-initialization without a constructor.

    SK_ListInitialization,

    /// Unwrap the single-element initializer list for a reference.

    SK_UnwrapInitList,

    /// Rewrap the single-element initializer list for a reference.

    SK_RewrapInitList,

    /// Perform initialization via a constructor.

    SK_ConstructorInitialization,

    /// Perform initialization via a constructor, taking arguments from

    /// a single InitListExpr.

    SK_ConstructorInitializationFromList,

    /// Zero-initialize the object

    SK_ZeroInitialization,

    /// C assignment