//===--- LambdaCapture.h - Types for C++ Lambda Captures --------*- 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

//

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

///

/// \file

/// Defines the LambdaCapture class.

///

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

#ifndef LLVM_CLANG_AST_LAMBDACAPTURE_H

#define LLVM_CLANG_AST_LAMBDACAPTURE_H

#include "clang/AST/Decl.h"

#include "clang/Basic/Lambda.h"

#include "llvm/ADT/PointerIntPair.h"

namespace clang {

/// Describes the capture of a variable or of \c this, or of a

/// C++1y init-capture.

class LambdaCapture {

  enum {

    /// Flag used by the Capture class to indicate that the given

    /// capture was implicit.

    Capture_Implicit = 0x01,

    /// Flag used by the Capture class to indicate that the

    /// given capture was by-copy.

    ///

    /// This includes the case of a non-reference init-capture.

    Capture_ByCopy = 0x02,

    /// Flag used by the Capture class to distinguish between a capture

    /// of '*this' and a capture of a VLA type.

    Capture_This = 0x04

  };

  // Decl could represent:

  // - a VarDecl* that represents the variable that was captured or the

  //   init-capture.

  // - or, is a nullptr and Capture_This is set in Bits if this represents a

  //   capture of '*this' by value or reference.

  // - or, is a nullptr and Capture_This is not set in Bits if this represents

  //   a capture of a VLA type.

  llvm::PointerIntPair<Decl*, 3> DeclAndBits;

  SourceLocation Loc;

  SourceLocation EllipsisLoc;

  friend class ASTStmtReader;

  friend class ASTStmtWriter;

public:

  /// Create a new capture of a variable or of \c this.

  ///

  /// \param Loc The source location associated with this capture.

  ///

  /// \param Kind The kind of capture (this, byref, bycopy), which must

  /// not be init-capture.

  ///

  /// \param Implicit Whether the capture was implicit or explicit.

  ///

  /// \param Var The local variable being captured, or null if capturing

  /// \c this.

  ///

  /// \param EllipsisLoc The location of the ellipsis (...) for a

  /// capture that is a pack expansion, or an invalid source

  /// location to indicate that this is not a pack expansion.

  LambdaCapture(SourceLocation Loc, bool Implicit, LambdaCaptureKind Kind,

                VarDecl *Var = nullptr,

                SourceLocation EllipsisLoc = SourceLocation());

  /// Determine the kind of capture.

  LambdaCaptureKind getCaptureKind() const;

  /// Determine whether this capture handles the C++ \c this

  /// pointer.

  bool capturesThis() const {

    return DeclAndBits.getPointer() == nullptr &&

          
(DeclAndBits.getInt() & Capture_This)1.23k
;

  }

  /// Determine whether this capture handles a variable.

  bool capturesVariable() const {

    return isa_and_nonnull<VarDecl>(DeclAndBits.getPointer());

  }

  /// Determine whether this captures a variable length array bound

  /// expression.

  bool capturesVLAType() const {

    return DeclAndBits.getPointer() == nullptr &&

           
!(DeclAndBits.getInt() & Capture_This)594
;

  }

  /// Retrieve the declaration of the local variable being

  /// captured.

  ///

  /// This operation is only valid if this capture is a variable capture

  /// (other than a capture of \c this).

  VarDecl *getCapturedVar() const {

    assert(capturesVariable() && "No variable available for capture");

    return static_cast<VarDecl *>(DeclAndBits.getPointer());

  }

  /// Determine whether this was an implicit capture (not

  /// written between the square brackets introducing the lambda).

  bool isImplicit() const {

    return DeclAndBits.getInt() & Capture_Implicit;

  }

  /// Determine whether this was an explicit capture (written

  /// between the square brackets introducing the lambda).

  bool isExplicit() const { return !isImplicit(); }

  /// Retrieve the source location of the capture.

  ///

  /// For an explicit capture, this returns the location of the

  /// explicit capture in the source. For an implicit capture, this

  /// returns the location at which the variable or \c this was first

  /// used.

  SourceLocation getLocation() const { return Loc; }

  /// Determine whether this capture is a pack expansion,

  /// which captures a function parameter pack.

  bool isPackExpansion() const { return EllipsisLoc.isValid(); }

  /// Retrieve the location of the ellipsis for a capture

  /// that is a pack expansion.

  SourceLocation getEllipsisLoc() const {

    assert(isPackExpansion() && "No ellipsis location for a non-expansion");

    return EllipsisLoc;

  }

};

} // end namespace clang

#endif // LLVM_CLANG_AST_LAMBDACAPTURE_H