clang 10.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.
25 class LambdaCapture {
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.
73 LambdaCapture(SourceLocation Loc, bool Implicit, LambdaCaptureKind Kind,
74 VarDecl *Var = nullptr,
75 SourceLocation EllipsisLoc = SourceLocation());
76
77 /// Determine the kind of capture.
78 LambdaCaptureKind getCaptureKind() const;
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).
104 VarDecl *getCapturedVar() const {
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.
133 SourceLocation getEllipsisLoc() const {
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::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::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:1133
clang::ASTStmtReader
Definition: ASTReaderStmt.cpp:69
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::LambdaCapture
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:25
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:820
clang::LambdaCaptureKind
LambdaCaptureKind
The different capture forms in a lambda introducer.
Definition: Lambda.h:33
clang::LambdaCapture::capturesThis
bool capturesThis() const
Determine whether this capture handles the C++ this pointer.
Definition: LambdaCapture.h:82
clang::ASTStmtWriter
Definition: ASTWriterStmt.cpp:31
clang::LambdaCapture::capturesVariable
bool capturesVariable() const
Determine whether this capture handles a variable.
Definition: LambdaCapture.h:88
Kind
Kind
Definition: ChrootChecker.cpp:29
clang::LambdaCapture::getEllipsisLoc
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis for a capture that is a pack expansion.
Definition: LambdaCapture.h:133
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
Lambda.h
Defines several types used to describe C++ lambda expressions that are shared between the parser and ...
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
Decl.h
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:106
clang::LambdaCapture::getCaptureKind
LambdaCaptureKind getCaptureKind() const
Determine the kind of capture.
Definition: ExprCXX.cpp:1163
clang::LambdaCapture::capturesVLAType
bool capturesVLAType() const
Determine whether this captures a variable length array bound expression.
Definition: LambdaCapture.h:94
clang::LambdaCapture::getLocation
SourceLocation getLocation() const
Retrieve the source location of the capture.
Definition: LambdaCapture.h:125