1 files changed, 141 insertions, 0 deletions
diff --git a/clang-r353983/include/clang/AST/LambdaCapture.h b/clang-r353983/include/clang/AST/LambdaCapture.h
new file mode 100644
index 00000000..8e280654
--- /dev/null
+++ b/clang-r353983/include/clang/AST/LambdaCapture.h
@@ -0,0 +1,141 @@
+//===--- 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);
+  }
+
+  /// Determine whether this capture handles a variable.
+  bool capturesVariable() const {
+    return dyn_cast_or_null<VarDecl>(DeclAndBits.getPointer());
+  }
+
+  /// Determine whether this captures a variable length array bound
+  /// expression.
+  bool capturesVLAType() const {
+    return DeclAndBits.getPointer() == nullptr &&
+           !(DeclAndBits.getInt() & Capture_This);
+  }
+
+  /// 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