Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- ConstructionContext.h - CFG constructor information ------*- 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 defines the ConstructionContext class and its sub-classes,

// which represent various different ways of constructing C++ objects

// with the additional information the users may want to know about

// the constructor.

//

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

#ifndef LLVM_CLANG_ANALYSIS_CONSTRUCTIONCONTEXT_H

#define LLVM_CLANG_ANALYSIS_CONSTRUCTIONCONTEXT_H

#include "clang/Analysis/Support/BumpVector.h"

#include "clang/AST/ExprCXX.h"

#include "clang/AST/ExprObjC.h"

namespace clang {

/// Represents a single point (AST node) in the program that requires attention

/// during construction of an object. ConstructionContext would be represented

/// as a list of such items.

class ConstructionContextItem {

public:

  enum ItemKind {

    VariableKind,

    NewAllocatorKind,

    ReturnKind,

    MaterializationKind,

    TemporaryDestructorKind,

    ElidedDestructorKind,

    ElidableConstructorKind,

    ArgumentKind,

    LambdaCaptureKind,

    STATEMENT_WITH_INDEX_KIND_BEGIN = ArgumentKind,

    STATEMENT_WITH_INDEX_KIND_END = LambdaCaptureKind,

    STATEMENT_KIND_BEGIN = VariableKind,

    STATEMENT_KIND_END = LambdaCaptureKind,

    InitializerKind,

    INITIALIZER_KIND_BEGIN = InitializerKind,

    INITIALIZER_KIND_END = InitializerKind

  };

  LLVM_DUMP_METHOD static StringRef getKindAsString(ItemKind K) {

    switch (K) {

      case VariableKind:            return "construct into local variable";

      case NewAllocatorKind:        return "construct into new-allocator";

      case ReturnKind:              return "construct into return address";

      case MaterializationKind:     return "materialize temporary";

      case TemporaryDestructorKind: return "destroy temporary";

      case ElidedDestructorKind:    return "elide destructor";

      case ElidableConstructorKind: return "elide constructor";

      case ArgumentKind:            return "construct into argument";

      case LambdaCaptureKind:

        return "construct into lambda captured variable";

      case InitializerKind:         return "construct into member variable";

    };

    llvm_unreachable("Unknown ItemKind");

  }

private:

  const void *const Data;

  const ItemKind Kind;

  const unsigned Index = 0;

  bool hasStatement() const {

    return Kind >= STATEMENT_KIND_BEGIN &&

           Kind <= STATEMENT_KIND_END;

  }

  bool hasIndex() const {

    return Kind >= STATEMENT_WITH_INDEX_KIND_BEGIN &&

           Kind <= STATEMENT_WITH_INDEX_KIND_END;

  }

  bool hasInitializer() const {

    return Kind >= INITIALIZER_KIND_BEGIN &&

           Kind <= INITIALIZER_KIND_END;

  }

public:

  // ConstructionContextItem should be simple enough so that it was easy to

  // re-construct it from the AST node it captures. For that reason we provide

  // simple implicit conversions from all sorts of supported AST nodes.

  ConstructionContextItem(const DeclStmt *DS)

      : Data(DS), Kind(VariableKind) {}

  ConstructionContextItem(const CXXNewExpr *NE)

      : Data(NE), Kind(NewAllocatorKind) {}

  ConstructionContextItem(const ReturnStmt *RS)

      : Data(RS), Kind(ReturnKind) {}

  ConstructionContextItem(const MaterializeTemporaryExpr *MTE)

      : Data(MTE), Kind(MaterializationKind) {}

  ConstructionContextItem(const CXXBindTemporaryExpr *BTE,

                          bool IsElided = false)

      : Data(BTE),

        Kind(IsElided ? ElidedDestructorKind : TemporaryDestructorKind) {}

  ConstructionContextItem(const CXXConstructExpr *CE)

      : Data(CE), Kind(ElidableConstructorKind) {}

  ConstructionContextItem(const CallExpr *CE, unsigned Index)

      : Data(CE), Kind(ArgumentKind), Index(Index) {}

  ConstructionContextItem(const CXXConstructExpr *CE, unsigned Index)

      : Data(CE), Kind(ArgumentKind), Index(Index) {}

  ConstructionContextItem(const CXXInheritedCtorInitExpr *CE, unsigned Index)

      : Data(CE), Kind(ArgumentKind), Index(Index) {}

  ConstructionContextItem(const ObjCMessageExpr *ME, unsigned Index)

      : Data(ME), Kind(ArgumentKind), Index(Index) {}

  // A polymorphic version of the previous calls with dynamic type check.

  ConstructionContextItem(const Expr *E, unsigned Index)

      : Data(E), Kind(ArgumentKind), Index(Index) {

    assert(isa<CallExpr>(E) || isa<CXXConstructExpr>(E) ||

           isa<CXXDeleteExpr>(E) || isa<CXXInheritedCtorInitExpr>(E) ||

           isa<ObjCMessageExpr>(E));

  }

  ConstructionContextItem(const CXXCtorInitializer *Init)

      : Data(Init), Kind(InitializerKind), Index(0) {}

  ConstructionContextItem(const LambdaExpr *LE, unsigned Index)

      : Data(LE), Kind(LambdaCaptureKind), Index(Index) {}

  ItemKind getKind() const { return Kind; }

  LLVM_DUMP_METHOD StringRef getKindAsString() const {

    return getKindAsString(getKind());

  }

  /// The construction site - the statement that triggered the construction

  /// for one of its parts. For instance, stack variable declaration statement

  /// triggers construction of itself or its elements if it's an array,

  /// new-expression triggers construction of the newly allocated object(s).

  const Stmt *getStmt() const {

    assert(hasStatement());

    return static_cast<const Stmt *>(Data);

  }

  const Stmt *getStmtOrNull() const {

    return hasStatement() ? getStmt() : nullptr;

  }

  /// The construction site is not necessarily a statement. It may also be a

  /// CXXCtorInitializer, which means that a member variable is being

  /// constructed during initialization of the object that contains it.

  const CXXCtorInitializer *getCXXCtorInitializer() const {

    assert(hasInitializer());

    return static_cast<const CXXCtorInitializer *>(Data);

  }

  /// If a single trigger statement triggers multiple constructors, they are

  /// usually being enumerated. This covers function argument constructors

  /// triggered by a call-expression and items in an initializer list triggered

  /// by an init-list-expression.

  unsigned getIndex() const {

    // This is a fairly specific request. Let's make sure the user knows

    // what he's doing.

    assert(hasIndex());

    return Index;

  }

  void Profile(llvm::FoldingSetNodeID &ID) const {

    ID.AddPointer(Data);

    ID.AddInteger(Kind);

    ID.AddInteger(Index);

  }

  bool operator==(const ConstructionContextItem &Other) const {

    // For most kinds the Index comparison is trivially true, but

    // checking kind separately doesn't seem to be less expensive

    // than checking Index. Same in operator<().

    return std::make_tuple(Data, Kind, Index) ==

           std::make_tuple(Other.Data, Other.Kind, Other.Index);

  }

  bool operator<(const ConstructionContextItem &Other) const {

    return std::make_tuple(Data, Kind, Index) <

           std::make_tuple(Other.Data, Other.Kind, Other.Index);

  }

};

/// Construction context can be seen as a linked list of multiple layers.

/// Sometimes a single trigger is not enough to describe the construction

/// site. That's what causing us to have a chain of "partial" construction

/// context layers. Some examples:

/// - A constructor within in an aggregate initializer list within a variable

///   would have a construction context of the initializer list with

///   the parent construction context of a variable.

/// - A constructor for a temporary that needs to be both destroyed

///   and materialized into an elidable copy constructor would have a

///   construction context of a CXXBindTemporaryExpr with the parent

///   construction context of a MaterializeTemproraryExpr.

/// Not all of these are currently supported.

/// Layers are created gradually while traversing the AST, and layers that

/// represent the outmost AST nodes are built first, while the node that

/// immediately contains the constructor would be built last and capture the

/// previous layers as its parents. Construction context captures the last layer

/// (which has links to the previous layers) and classifies the seemingly

/// arbitrary chain of layers into one of the possible ways of constructing

/// an object in C++ for user-friendly experience.

class ConstructionContextLayer {

  const ConstructionContextLayer *Parent = nullptr;

  ConstructionContextItem Item;

  ConstructionContextLayer(ConstructionContextItem Item,

                           const ConstructionContextLayer *Parent)

      : Parent(Parent), Item(Item) {}

public:

  static const ConstructionContextLayer *

  create(BumpVectorContext &C, const ConstructionContextItem &Item,

         const ConstructionContextLayer *Parent = nullptr);

  const ConstructionContextItem &getItem() const { return Item; }

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

  bool isLast() const { return !Parent; }

  /// See if Other is a proper initial segment of this construction context

  /// in terms of the parent chain - i.e. a few first parents coincide and

  /// then the other context terminates but our context goes further - i.e.,

  /// we are providing the same context that the other context provides,

  /// and a bit more above that.

  bool isStrictlyMoreSpecificThan(const ConstructionContextLayer *Other) const;

};

/// ConstructionContext's subclasses describe different ways of constructing

/// an object in C++. The context re-captures the essential parent AST nodes

/// of the CXXConstructExpr it is assigned to and presents these nodes

/// through easy-to-understand accessor methods.

class ConstructionContext {

public:

  enum Kind {

    SimpleVariableKind,

    CXX17ElidedCopyVariableKind,

    VARIABLE_BEGIN = SimpleVariableKind,

    VARIABLE_END = CXX17ElidedCopyVariableKind,

    SimpleConstructorInitializerKind,

    CXX17ElidedCopyConstructorInitializerKind,

    INITIALIZER_BEGIN = SimpleConstructorInitializerKind,

    INITIALIZER_END = CXX17ElidedCopyConstructorInitializerKind,

    NewAllocatedObjectKind,

    SimpleTemporaryObjectKind,

    ElidedTemporaryObjectKind,

    TEMPORARY_BEGIN = SimpleTemporaryObjectKind,

    TEMPORARY_END = ElidedTemporaryObjectKind,

    SimpleReturnedValueKind,

    CXX17ElidedCopyReturnedValueKind,

    RETURNED_VALUE_BEGIN = SimpleReturnedValueKind,

    RETURNED_VALUE_END = CXX17ElidedCopyReturnedValueKind,

    ArgumentKind,

    LambdaCaptureKind

  };

protected:

  Kind K;

  // Do not make public! These need to only be constructed

  // via createFromLayers().

  explicit ConstructionContext(Kind K) : K(K) {}

private:

  // A helper function for constructing an instance into a bump vector context.

  template <typename T, typename... ArgTypes>

  static T *create(BumpVectorContext &C, ArgTypes... Args) {

    auto *CC = C.getAllocator().Allocate<T>();

    return new (CC) T(Args...);

  }

  // A sub-routine of createFromLayers() that deals with temporary objects

  // that need to be materialized. The BTE argument is for the situation when

  // the object also needs to be bound for destruction.

  static const ConstructionContext *createMaterializedTemporaryFromLayers(

      BumpVectorContext &C, const MaterializeTemporaryExpr *MTE,

      const CXXBindTemporaryExpr *BTE,

      const ConstructionContextLayer *ParentLayer);

  // A sub-routine of createFromLayers() that deals with temporary objects

  // that need to be bound for destruction. Automatically finds out if the

  // object also needs to be materialized and delegates to

  // createMaterializedTemporaryFromLayers() if necessary.

  static const ConstructionContext *

  createBoundTemporaryFromLayers(

      BumpVectorContext &C, const CXXBindTemporaryExpr *BTE,

      const ConstructionContextLayer *ParentLayer);

public:

  /// Consume the construction context layer, together with its parent layers,

  /// and wrap it up into a complete construction context. May return null

  /// if layers do not form any supported construction context.

  static const ConstructionContext *

  createFromLayers(BumpVectorContext &C,

                   const ConstructionContextLayer *TopLayer);

  Kind getKind() const { return K; }

  virtual const ArrayInitLoopExpr *getArrayInitLoop() const { return nullptr; }

  // Only declared to silence -Wnon-virtual-dtor warnings.

  virtual ~ConstructionContext() = default;

};

/// An abstract base class for local variable constructors.

class VariableConstructionContext : public ConstructionContext {

  const DeclStmt *DS;

protected:

  VariableConstructionContext(ConstructionContext::Kind K, const DeclStmt *DS)

      : ConstructionContext(K), DS(DS) {

    assert(classof(this));

    assert(DS);

  }

public:

  const DeclStmt *getDeclStmt() const { return DS; }

  const ArrayInitLoopExpr *getArrayInitLoop() const override {

    const auto *Var = cast<VarDecl>(DS->getSingleDecl());

    return dyn_cast<ArrayInitLoopExpr>(Var->getInit());

  }

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() >= VARIABLE_BEGIN &&

           CC->getKind() <= VARIABLE_END;

  }

};

/// Represents construction into a simple local variable, eg. T var(123);.

/// If a variable has an initializer, eg. T var = makeT();, then the final

/// elidable copy-constructor from makeT() into var would also be a simple

/// variable constructor handled by this class.

class SimpleVariableConstructionContext : public VariableConstructionContext {

  friend class ConstructionContext; // Allows to create<>() itself.

  explicit SimpleVariableConstructionContext(const DeclStmt *DS)

      : VariableConstructionContext(ConstructionContext::SimpleVariableKind,

                                    DS) {}

public:

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() == SimpleVariableKind;

  }

};

/// Represents construction into a simple variable with an initializer syntax,

/// with a single constructor, eg. T var = makeT();. Such construction context

/// may only appear in C++17 because previously it was split into a temporary

/// object constructor and an elidable simple variable copy-constructor and

/// we were producing separate construction contexts for these constructors.

/// In C++17 we have a single construction context that combines both.

/// Note that if the object has trivial destructor, then this code is

/// indistinguishable from a simple variable constructor on the AST level;

/// in this case we provide a simple variable construction context.

class CXX17ElidedCopyVariableConstructionContext

    : public VariableConstructionContext {

  const CXXBindTemporaryExpr *BTE;

  friend class ConstructionContext; // Allows to create<>() itself.

  explicit CXX17ElidedCopyVariableConstructionContext(

      const DeclStmt *DS, const CXXBindTemporaryExpr *BTE)

      : VariableConstructionContext(CXX17ElidedCopyVariableKind, DS), BTE(BTE) {

    assert(BTE);

  }

public:

  const CXXBindTemporaryExpr *getCXXBindTemporaryExpr() const { return BTE; }

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() == CXX17ElidedCopyVariableKind;

  }

};

// An abstract base class for constructor-initializer-based constructors.

class ConstructorInitializerConstructionContext : public ConstructionContext {

  const CXXCtorInitializer *I;

protected:

  explicit ConstructorInitializerConstructionContext(

      ConstructionContext::Kind K, const CXXCtorInitializer *I)

      : ConstructionContext(K), I(I) {

    assert(classof(this));

    assert(I);

  }

public:

  const CXXCtorInitializer *getCXXCtorInitializer() const { return I; }

  const ArrayInitLoopExpr *getArrayInitLoop() const override {

    return dyn_cast<ArrayInitLoopExpr>(I->getInit());

  }

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() >= INITIALIZER_BEGIN &&

           CC->getKind() <= INITIALIZER_END;

  }

};

/// Represents construction into a field or a base class within a bigger object

/// via a constructor initializer, eg. T(): field(123) { ... }.

class SimpleConstructorInitializerConstructionContext

    : public ConstructorInitializerConstructionContext {

  friend class ConstructionContext; // Allows to create<>() itself.

  explicit SimpleConstructorInitializerConstructionContext(

      const CXXCtorInitializer *I)

      : ConstructorInitializerConstructionContext(

            ConstructionContext::SimpleConstructorInitializerKind, I) {}

public:

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() == SimpleConstructorInitializerKind;

  }

};

/// Represents construction into a field or a base class within a bigger object

/// via a constructor initializer, with a single constructor, eg.

/// T(): field(Field(123)) { ... }. Such construction context may only appear

/// in C++17 because previously it was split into a temporary object constructor

/// and an elidable simple constructor-initializer copy-constructor and we were

/// producing separate construction contexts for these constructors. In C++17

/// we have a single construction context that combines both. Note that if the

/// object has trivial destructor, then this code is indistinguishable from

/// a simple constructor-initializer constructor on the AST level; in this case

/// we provide a simple constructor-initializer construction context.

class CXX17ElidedCopyConstructorInitializerConstructionContext

    : public ConstructorInitializerConstructionContext {

  const CXXBindTemporaryExpr *BTE;

  friend class ConstructionContext; // Allows to create<>() itself.

  explicit CXX17ElidedCopyConstructorInitializerConstructionContext(

      const CXXCtorInitializer *I, const CXXBindTemporaryExpr *BTE)

      : ConstructorInitializerConstructionContext(

            CXX17ElidedCopyConstructorInitializerKind, I),

        BTE(BTE) {

    assert(BTE);

  }

public:

  const CXXBindTemporaryExpr *getCXXBindTemporaryExpr() const { return BTE; }

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() == CXX17ElidedCopyConstructorInitializerKind;

  }

};

/// Represents immediate initialization of memory allocated by operator new,

/// eg. new T(123);.

class NewAllocatedObjectConstructionContext : public ConstructionContext {

  const CXXNewExpr *NE;

  friend class ConstructionContext; // Allows to create<>() itself.

  explicit NewAllocatedObjectConstructionContext(const CXXNewExpr *NE)

      : ConstructionContext(ConstructionContext::NewAllocatedObjectKind),

        NE(NE) {

    assert(NE);

  }

public:

  const CXXNewExpr *getCXXNewExpr() const { return NE; }

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() == NewAllocatedObjectKind;

  }

};

/// Represents a temporary object, eg. T(123), that does not immediately cross

/// function boundaries "by value"; constructors that construct function

/// value-type arguments or values that are immediately returned from the

/// function that returns a value receive separate construction context kinds.

class TemporaryObjectConstructionContext : public ConstructionContext {

  const CXXBindTemporaryExpr *BTE;

  const MaterializeTemporaryExpr *MTE;

protected:

  explicit TemporaryObjectConstructionContext(

      ConstructionContext::Kind K, const CXXBindTemporaryExpr *BTE,

      const MaterializeTemporaryExpr *MTE)

      : ConstructionContext(K), BTE(BTE), MTE(MTE) {

    // Both BTE and MTE can be null here, all combinations possible.

    // Even though for now at least one should be non-null, we simply haven't

    // implemented the other case yet (this would be a temporary in the middle

    // of nowhere that doesn't have a non-trivial destructor).

  }

public:

  /// CXXBindTemporaryExpr here is non-null as long as the temporary has

  /// a non-trivial destructor.

  const CXXBindTemporaryExpr *getCXXBindTemporaryExpr() const {

    return BTE;

  }

  /// MaterializeTemporaryExpr is non-null as long as the temporary is actually

  /// used after construction, eg. by binding to a reference (lifetime

  /// extension), accessing a field, calling a method, or passing it into

  /// a function (an elidable copy or move constructor would be a common

  /// example) by reference.

  const MaterializeTemporaryExpr *getMaterializedTemporaryExpr() const {

    return MTE;

  }

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() >= TEMPORARY_BEGIN && CC->getKind() <= TEMPORARY_END;

  }

};

/// Represents a temporary object that is not constructed for the purpose of

/// being immediately copied/moved by an elidable copy/move-constructor.

/// This includes temporary objects "in the middle of nowhere" like T(123) and

/// lifetime-extended temporaries.

class SimpleTemporaryObjectConstructionContext

    : public TemporaryObjectConstructionContext {

  friend class ConstructionContext; // Allows to create<>() itself.

  explicit SimpleTemporaryObjectConstructionContext(

      const CXXBindTemporaryExpr *BTE, const MaterializeTemporaryExpr *MTE)

      : TemporaryObjectConstructionContext(

            ConstructionContext::SimpleTemporaryObjectKind, BTE, MTE) {}

public:

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() == SimpleTemporaryObjectKind;

  }

};

/// Represents a temporary object that is constructed for the sole purpose

/// of being immediately copied by an elidable copy/move constructor.

/// For example, T t = T(123); includes a temporary T(123) that is immediately

/// copied to variable t. In such cases the elidable copy can (but not

/// necessarily should) be omitted ("elided") according to the rules of the

/// language; the constructor would then construct variable t directly.

/// This construction context contains information of the elidable constructor

/// and its respective construction context.

class ElidedTemporaryObjectConstructionContext

    : public TemporaryObjectConstructionContext {

  const CXXConstructExpr *ElidedCE;

  const ConstructionContext *ElidedCC;

  friend class ConstructionContext; // Allows to create<>() itself.

  explicit ElidedTemporaryObjectConstructionContext(

      const CXXBindTemporaryExpr *BTE, const MaterializeTemporaryExpr *MTE,

      const CXXConstructExpr *ElidedCE, const ConstructionContext *ElidedCC)

      : TemporaryObjectConstructionContext(

            ConstructionContext::ElidedTemporaryObjectKind, BTE, MTE),

        ElidedCE(ElidedCE), ElidedCC(ElidedCC) {

    // Elided constructor and its context should be either both specified

    // or both unspecified. In the former case, the constructor must be

    // elidable.

    assert(ElidedCE && ElidedCE->isElidable() && ElidedCC);

  }

public:

  const CXXConstructExpr *getConstructorAfterElision() const {

    return ElidedCE;

  }

  const ConstructionContext *getConstructionContextAfterElision() const {

    return ElidedCC;

  }

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() == ElidedTemporaryObjectKind;

  }

};

class ReturnedValueConstructionContext : public ConstructionContext {

  const ReturnStmt *RS;

protected:

  explicit ReturnedValueConstructionContext(ConstructionContext::Kind K,

                                            const ReturnStmt *RS)

      : ConstructionContext(K), RS(RS) {

    assert(classof(this));

    assert(RS);

  }

public:

  const ReturnStmt *getReturnStmt() const { return RS; }

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() >= RETURNED_VALUE_BEGIN &&

           CC->getKind() <= RETURNED_VALUE_END;

  }

};

/// Represents a temporary object that is being immediately returned from a

/// function by value, eg. return t; or return T(123);. In this case there is

/// always going to be a constructor at the return site. However, the usual

/// temporary-related bureaucracy (CXXBindTemporaryExpr,

/// MaterializeTemporaryExpr) is normally located in the caller function's AST.

class SimpleReturnedValueConstructionContext

    : public ReturnedValueConstructionContext {

  friend class ConstructionContext; // Allows to create<>() itself.

  explicit SimpleReturnedValueConstructionContext(const ReturnStmt *RS)

      : ReturnedValueConstructionContext(

            ConstructionContext::SimpleReturnedValueKind, RS) {}

public:

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() == SimpleReturnedValueKind;

  }

};

/// Represents a temporary object that is being immediately returned from a

/// function by value, eg. return t; or return T(123); in C++17.

/// In C++17 there is not going to be an elidable copy constructor at the

/// return site.  However, the usual temporary-related bureaucracy (CXXBindTemporaryExpr,

/// MaterializeTemporaryExpr) is normally located in the caller function's AST.

/// Note that if the object has trivial destructor, then this code is

/// indistinguishable from a simple returned value constructor on the AST level;

/// in this case we provide a simple returned value construction context.

class CXX17ElidedCopyReturnedValueConstructionContext

    : public ReturnedValueConstructionContext {

  const CXXBindTemporaryExpr *BTE;

  friend class ConstructionContext; // Allows to create<>() itself.

  explicit CXX17ElidedCopyReturnedValueConstructionContext(

      const ReturnStmt *RS, const CXXBindTemporaryExpr *BTE)

      : ReturnedValueConstructionContext(

            ConstructionContext::CXX17ElidedCopyReturnedValueKind, RS),

        BTE(BTE) {

    assert(BTE);

  }

public:

  const CXXBindTemporaryExpr *getCXXBindTemporaryExpr() const { return BTE; }

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() == CXX17ElidedCopyReturnedValueKind;

  }

};

class ArgumentConstructionContext : public ConstructionContext {

  // The call of which the context is an argument.

  const Expr *CE;

  // Which argument we're constructing. Note that when numbering between

  // arguments and parameters is inconsistent (eg., operator calls),

  // this is the index of the argument, not of the parameter.

  unsigned Index;

  // Whether the object needs to be destroyed.

  const CXXBindTemporaryExpr *BTE;

  friend class ConstructionContext; // Allows to create<>() itself.

  explicit ArgumentConstructionContext(const Expr *CE, unsigned Index,

                                       const CXXBindTemporaryExpr *BTE)

      : ConstructionContext(ArgumentKind), CE(CE),

        Index(Index), BTE(BTE) {

    assert(isa<CallExpr>(CE) || isa<CXXConstructExpr>(CE) ||

           isa<ObjCMessageExpr>(CE));

    // BTE is optional.

  }

public:

  const Expr *getCallLikeExpr() const { return CE; }

  unsigned getIndex() const { return Index; }

  const CXXBindTemporaryExpr *getCXXBindTemporaryExpr() const { return BTE; }

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() == ArgumentKind;

  }

};

class LambdaCaptureConstructionContext : public ConstructionContext {

  // The lambda of which the initializer we capture.

  const LambdaExpr *LE;

  // Index of the captured element in the captured list.

  unsigned Index;

  friend class ConstructionContext; // Allows to create<>() itself.

  explicit LambdaCaptureConstructionContext(const LambdaExpr *LE,

                                            unsigned Index)

      : ConstructionContext(LambdaCaptureKind), LE(LE), Index(Index) {}

public:

  const LambdaExpr *getLambdaExpr() const { return LE; }

  unsigned getIndex() const { return Index; }

  const Expr *getInitializer() const {

    return *(LE->capture_init_begin() + Index);

  }

  const FieldDecl *getFieldDecl() const {

    auto It = LE->getLambdaClass()->field_begin();

    std::advance(It, Index);

    return *It;

  }

  const ArrayInitLoopExpr *getArrayInitLoop() const override {

    return dyn_cast_or_null<ArrayInitLoopExpr>(getInitializer());

  }

  static bool classof(const ConstructionContext *CC) {

    return CC->getKind() == LambdaCaptureKind;

  }

};

} // end namespace clang

#endif // LLVM_CLANG_ANALYSIS_CONSTRUCTIONCONTEXT_H