clang  9.0.0svn
LambdaCapture.h
Go to the documentation of this file.
1 //===--- LambdaCapture.h - Types for C++ Lambda Captures --------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// Defines the LambdaCapture class.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_AST_LAMBDACAPTURE_H
15 #define LLVM_CLANG_AST_LAMBDACAPTURE_H
16 
17 #include "clang/AST/Decl.h"
18 #include "clang/Basic/Lambda.h"
19 #include "llvm/ADT/PointerIntPair.h"
20 
21 namespace clang {
22 
23 /// Describes the capture of a variable or of \c this, or of a
24 /// C++1y init-capture.
26  enum {
27  /// Flag used by the Capture class to indicate that the given
28  /// capture was implicit.
29  Capture_Implicit = 0x01,
30 
31  /// Flag used by the Capture class to indicate that the
32  /// given capture was by-copy.
33  ///
34  /// This includes the case of a non-reference init-capture.
35  Capture_ByCopy = 0x02,
36 
37  /// Flag used by the Capture class to distinguish between a capture
38  /// of '*this' and a capture of a VLA type.
39  Capture_This = 0x04
40  };
41 
42  // Decl could represent:
43  // - a VarDecl* that represents the variable that was captured or the
44  // init-capture.
45  // - or, is a nullptr and Capture_This is set in Bits if this represents a
46  // capture of '*this' by value or reference.
47  // - or, is a nullptr and Capture_This is not set in Bits if this represents
48  // a capture of a VLA type.
49  llvm::PointerIntPair<Decl*, 3> DeclAndBits;
50 
51  SourceLocation Loc;
52  SourceLocation EllipsisLoc;
53 
54  friend class ASTStmtReader;
55  friend class ASTStmtWriter;
56 
57 public:
58  /// Create a new capture of a variable or of \c this.
59  ///
60  /// \param Loc The source location associated with this capture.
61  ///
62  /// \param Kind The kind of capture (this, byref, bycopy), which must
63  /// not be init-capture.
64  ///
65  /// \param Implicit Whether the capture was implicit or explicit.
66  ///
67  /// \param Var The local variable being captured, or null if capturing
68  /// \c this.
69  ///
70  /// \param EllipsisLoc The location of the ellipsis (...) for a
71  /// capture that is a pack expansion, or an invalid source
72  /// location to indicate that this is not a pack expansion.
74  VarDecl *Var = nullptr,
75  SourceLocation EllipsisLoc = SourceLocation());
76 
77  /// Determine the kind of capture.
79 
80  /// Determine whether this capture handles the C++ \c this
81  /// pointer.
82  bool capturesThis() const {
83  return DeclAndBits.getPointer() == nullptr &&
84  (DeclAndBits.getInt() & Capture_This);
85  }
86 
87  /// Determine whether this capture handles a variable.
88  bool capturesVariable() const {
89  return dyn_cast_or_null<VarDecl>(DeclAndBits.getPointer());
90  }
91 
92  /// Determine whether this captures a variable length array bound
93  /// expression.
94  bool capturesVLAType() const {
95  return DeclAndBits.getPointer() == nullptr &&
96  !(DeclAndBits.getInt() & Capture_This);
97  }
98 
99  /// Retrieve the declaration of the local variable being
100  /// captured.
101  ///
102  /// This operation is only valid if this capture is a variable capture
103  /// (other than a capture of \c this).
105  assert(capturesVariable() && "No variable available for capture");
106  return static_cast<VarDecl *>(DeclAndBits.getPointer());
107  }
108 
109  /// Determine whether this was an implicit capture (not
110  /// written between the square brackets introducing the lambda).
111  bool isImplicit() const {
112  return DeclAndBits.getInt() & Capture_Implicit;
113  }
114 
115  /// Determine whether this was an explicit capture (written
116  /// between the square brackets introducing the lambda).
117  bool isExplicit() const { return !isImplicit(); }
118 
119  /// Retrieve the source location of the capture.
120  ///
121  /// For an explicit capture, this returns the location of the
122  /// explicit capture in the source. For an implicit capture, this
123  /// returns the location at which the variable or \c this was first
124  /// used.
125  SourceLocation getLocation() const { return Loc; }
126 
127  /// Determine whether this capture is a pack expansion,
128  /// which captures a function parameter pack.
129  bool isPackExpansion() const { return EllipsisLoc.isValid(); }
130 
131  /// Retrieve the location of the ellipsis for a capture
132  /// that is a pack expansion.
134  assert(isPackExpansion() && "No ellipsis location for a non-expansion");
135  return EllipsisLoc;
136  }
137 };
138 
139 } // end namespace clang
140 
141 #endif // LLVM_CLANG_AST_LAMBDACAPTURE_H
VarDecl * getCapturedVar() const
Retrieve the declaration of the local variable being captured.
bool isImplicit() const
Determine whether this was an implicit capture (not written between the square brackets introducing t...
LambdaCapture(SourceLocation Loc, bool Implicit, LambdaCaptureKind Kind, VarDecl *Var=nullptr, SourceLocation EllipsisLoc=SourceLocation())
Create a new capture of a variable or of this.
Definition: ExprCXX.cpp:1045
bool isPackExpansion() const
Determine whether this capture is a pack expansion, which captures a function parameter pack...
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:25
Represents a variable declaration or definition.
Definition: Decl.h:812
LambdaCaptureKind
The different capture forms in a lambda introducer.
Definition: Lambda.h:33
bool capturesThis() const
Determine whether this capture handles the C++ this pointer.
Definition: LambdaCapture.h:82
bool capturesVariable() const
Determine whether this capture handles a variable.
Definition: LambdaCapture.h:88
Kind
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis for a capture that is a pack expansion.
Encodes a location in the source.
Defines several types used to describe C++ lambda expressions that are shared between the parser and ...
bool isExplicit() const
Determine whether this was an explicit capture (written between the square brackets introducing the l...
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
LambdaCaptureKind getCaptureKind() const
Determine the kind of capture.
Definition: ExprCXX.cpp:1075
bool capturesVLAType() const
Determine whether this captures a variable length array bound expression.
Definition: LambdaCapture.h:94
SourceLocation getLocation() const
Retrieve the source location of the capture.