clang  13.0.0git
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
clang::LambdaCapture::capturesThis
bool capturesThis() const
Determine whether this capture handles the C++ this pointer.
Definition: LambdaCapture.h:82
clang::LambdaCapture
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:25
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:89
clang::ASTStmtWriter
Definition: ASTWriterStmt.cpp:32
clang::LambdaCapture::getLocation
SourceLocation getLocation() const
Retrieve the source location of the capture.
Definition: LambdaCapture.h:125
Decl.h
clang::LambdaCapture::getCapturedVar
VarDecl * getCapturedVar() const
Retrieve the declaration of the local variable being captured.
Definition: LambdaCapture.h:104
clang::LambdaCapture::isImplicit
bool isImplicit() const
Determine whether this was an implicit capture (not written between the square brackets introducing t...
Definition: LambdaCapture.h:111
clang::ASTStmtReader
Definition: ASTReaderStmt.cpp:71
clang::LambdaCapture::isExplicit
bool isExplicit() const
Determine whether this was an explicit capture (written between the square brackets introducing the l...
Definition: LambdaCapture.h:117
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:844
clang::LambdaCapture::capturesVLAType
bool capturesVLAType() const
Determine whether this captures a variable length array bound expression.
Definition: LambdaCapture.h:94
clang::LambdaCapture::getCaptureKind
LambdaCaptureKind getCaptureKind() const
Determine the kind of capture.
Definition: ExprCXX.cpp:1113
clang::LambdaCaptureKind
LambdaCaptureKind
The different capture forms in a lambda introducer.
Definition: Lambda.h:33
clang::LambdaCapture::LambdaCapture
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:1083
Lambda.h
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang
Dataflow Directional Tag Classes.
Definition: CalledOnceCheck.h:17
clang::LambdaCapture::isPackExpansion
bool isPackExpansion() const
Determine whether this capture is a pack expansion, which captures a function parameter pack.
Definition: LambdaCapture.h:129
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:110
clang::LambdaCapture::capturesVariable
bool capturesVariable() const
Determine whether this capture handles a variable.
Definition: LambdaCapture.h:88
clang::LambdaCapture::getEllipsisLoc
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis for a capture that is a pack expansion.
Definition: LambdaCapture.h:133