/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/AST/StmtCXX.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- StmtCXX.h - Classes for representing C++ statements ----*- 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 | | // This file defines the C++ statement AST node classes. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #ifndef LLVM_CLANG_AST_STMTCXX_H |
14 | | #define LLVM_CLANG_AST_STMTCXX_H |
15 | | |
16 | | #include "clang/AST/DeclarationName.h" |
17 | | #include "clang/AST/Expr.h" |
18 | | #include "clang/AST/NestedNameSpecifier.h" |
19 | | #include "clang/AST/Stmt.h" |
20 | | #include "llvm/Support/Compiler.h" |
21 | | |
22 | | namespace clang { |
23 | | |
24 | | class VarDecl; |
25 | | |
26 | | /// CXXCatchStmt - This represents a C++ catch block. |
27 | | /// |
28 | | class CXXCatchStmt : public Stmt { |
29 | | SourceLocation CatchLoc; |
30 | | /// The exception-declaration of the type. |
31 | | VarDecl *ExceptionDecl; |
32 | | /// The handler block. |
33 | | Stmt *HandlerBlock; |
34 | | |
35 | | public: |
36 | | CXXCatchStmt(SourceLocation catchLoc, VarDecl *exDecl, Stmt *handlerBlock) |
37 | | : Stmt(CXXCatchStmtClass), CatchLoc(catchLoc), ExceptionDecl(exDecl), |
38 | 10.8k | HandlerBlock(handlerBlock) {} |
39 | | |
40 | | CXXCatchStmt(EmptyShell Empty) |
41 | 23 | : Stmt(CXXCatchStmtClass), ExceptionDecl(nullptr), HandlerBlock(nullptr) {} |
42 | | |
43 | 316 | SourceLocation getBeginLoc() const LLVM_READONLY { return CatchLoc; } |
44 | 561 | SourceLocation getEndLoc() const LLVM_READONLY { |
45 | 561 | return HandlerBlock->getEndLoc(); |
46 | 561 | } |
47 | | |
48 | 978 | SourceLocation getCatchLoc() const { return CatchLoc; } |
49 | 15.0k | VarDecl *getExceptionDecl() const { return ExceptionDecl; } |
50 | | QualType getCaughtType() const; |
51 | 2.16k | Stmt *getHandlerBlock() const { return HandlerBlock; } |
52 | | |
53 | 13.4k | static bool classof(const Stmt *T) { |
54 | 13.4k | return T->getStmtClass() == CXXCatchStmtClass; |
55 | 13.4k | } |
56 | | |
57 | 2.15k | child_range children() { return child_range(&HandlerBlock, &HandlerBlock+1); } |
58 | | |
59 | 0 | const_child_range children() const { |
60 | 0 | return const_child_range(&HandlerBlock, &HandlerBlock + 1); |
61 | 0 | } |
62 | | |
63 | | friend class ASTStmtReader; |
64 | | }; |
65 | | |
66 | | /// CXXTryStmt - A C++ try block, including all handlers. |
67 | | /// |
68 | | class CXXTryStmt final : public Stmt, |
69 | | private llvm::TrailingObjects<CXXTryStmt, Stmt *> { |
70 | | |
71 | | friend TrailingObjects; |
72 | | friend class ASTStmtReader; |
73 | | |
74 | | SourceLocation TryLoc; |
75 | | unsigned NumHandlers; |
76 | 0 | size_t numTrailingObjects(OverloadToken<Stmt *>) const { return NumHandlers; } |
77 | | |
78 | | CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock, ArrayRef<Stmt*> handlers); |
79 | | CXXTryStmt(EmptyShell Empty, unsigned numHandlers) |
80 | 23 | : Stmt(CXXTryStmtClass), NumHandlers(numHandlers) { } |
81 | | |
82 | 1.55k | Stmt *const *getStmts() const { return getTrailingObjects<Stmt *>(); } |
83 | 18.3k | Stmt **getStmts() { return getTrailingObjects<Stmt *>(); } |
84 | | |
85 | | public: |
86 | | static CXXTryStmt *Create(const ASTContext &C, SourceLocation tryLoc, |
87 | | Stmt *tryBlock, ArrayRef<Stmt*> handlers); |
88 | | |
89 | | static CXXTryStmt *Create(const ASTContext &C, EmptyShell Empty, |
90 | | unsigned numHandlers); |
91 | | |
92 | 367 | SourceLocation getBeginLoc() const LLVM_READONLY { return getTryLoc(); } |
93 | | |
94 | 1.35k | SourceLocation getTryLoc() const { return TryLoc; } |
95 | 404 | SourceLocation getEndLoc() const { |
96 | 404 | return getStmts()[NumHandlers]->getEndLoc(); |
97 | 404 | } |
98 | | |
99 | 1.77k | CompoundStmt *getTryBlock() { |
100 | 1.77k | return cast<CompoundStmt>(getStmts()[0]); |
101 | 1.77k | } |
102 | 362 | const CompoundStmt *getTryBlock() const { |
103 | 362 | return cast<CompoundStmt>(getStmts()[0]); |
104 | 362 | } |
105 | | |
106 | 5.35k | unsigned getNumHandlers() const { return NumHandlers; } |
107 | 1.56k | CXXCatchStmt *getHandler(unsigned i) { |
108 | 1.56k | return cast<CXXCatchStmt>(getStmts()[i + 1]); |
109 | 1.56k | } |
110 | 790 | const CXXCatchStmt *getHandler(unsigned i) const { |
111 | 790 | return cast<CXXCatchStmt>(getStmts()[i + 1]); |
112 | 790 | } |
113 | | |
114 | 376k | static bool classof(const Stmt *T) { |
115 | 376k | return T->getStmtClass() == CXXTryStmtClass; |
116 | 376k | } |
117 | | |
118 | 2.11k | child_range children() { |
119 | 2.11k | return child_range(getStmts(), getStmts() + getNumHandlers() + 1); |
120 | 2.11k | } |
121 | | |
122 | 0 | const_child_range children() const { |
123 | 0 | return const_child_range(getStmts(), getStmts() + getNumHandlers() + 1); |
124 | 0 | } |
125 | | }; |
126 | | |
127 | | /// CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for |
128 | | /// statement, represented as 'for (range-declarator : range-expression)' |
129 | | /// or 'for (init-statement range-declarator : range-expression)'. |
130 | | /// |
131 | | /// This is stored in a partially-desugared form to allow full semantic |
132 | | /// analysis of the constituent components. The original syntactic components |
133 | | /// can be extracted using getLoopVariable and getRangeInit. |
134 | | class CXXForRangeStmt : public Stmt { |
135 | | SourceLocation ForLoc; |
136 | | enum { INIT, RANGE, BEGINSTMT, ENDSTMT, COND, INC, LOOPVAR, BODY, END }; |
137 | | // SubExprs[RANGE] is an expression or declstmt. |
138 | | // SubExprs[COND] and SubExprs[INC] are expressions. |
139 | | Stmt *SubExprs[END]; |
140 | | SourceLocation CoawaitLoc; |
141 | | SourceLocation ColonLoc; |
142 | | SourceLocation RParenLoc; |
143 | | |
144 | | friend class ASTStmtReader; |
145 | | public: |
146 | | CXXForRangeStmt(Stmt *InitStmt, DeclStmt *Range, DeclStmt *Begin, |
147 | | DeclStmt *End, Expr *Cond, Expr *Inc, DeclStmt *LoopVar, |
148 | | Stmt *Body, SourceLocation FL, SourceLocation CAL, |
149 | | SourceLocation CL, SourceLocation RPL); |
150 | 216 | CXXForRangeStmt(EmptyShell Empty) : Stmt(CXXForRangeStmtClass, Empty) { } |
151 | | |
152 | 1.63k | Stmt *getInit() { return SubExprs[INIT]; } |
153 | | VarDecl *getLoopVariable(); |
154 | | Expr *getRangeInit(); |
155 | | |
156 | 211 | const Stmt *getInit() const { return SubExprs[INIT]; } |
157 | | const VarDecl *getLoopVariable() const; |
158 | | const Expr *getRangeInit() const; |
159 | | |
160 | | |
161 | 1.95k | DeclStmt *getRangeStmt() { return cast<DeclStmt>(SubExprs[RANGE]); } |
162 | 846 | DeclStmt *getBeginStmt() { |
163 | 846 | return cast_or_null<DeclStmt>(SubExprs[BEGINSTMT]); |
164 | 846 | } |
165 | 774 | DeclStmt *getEndStmt() { return cast_or_null<DeclStmt>(SubExprs[ENDSTMT]); } |
166 | 1.14k | Expr *getCond() { return cast_or_null<Expr>(SubExprs[COND]); } |
167 | 650 | Expr *getInc() { return cast_or_null<Expr>(SubExprs[INC]); } |
168 | 2.11k | DeclStmt *getLoopVarStmt() { return cast<DeclStmt>(SubExprs[LOOPVAR]); } |
169 | 1.76k | Stmt *getBody() { return SubExprs[BODY]; } |
170 | | |
171 | 269 | const DeclStmt *getRangeStmt() const { |
172 | 269 | return cast<DeclStmt>(SubExprs[RANGE]); |
173 | 269 | } |
174 | 181 | const DeclStmt *getBeginStmt() const { |
175 | 181 | return cast_or_null<DeclStmt>(SubExprs[BEGINSTMT]); |
176 | 181 | } |
177 | 187 | const DeclStmt *getEndStmt() const { |
178 | 187 | return cast_or_null<DeclStmt>(SubExprs[ENDSTMT]); |
179 | 187 | } |
180 | 896 | const Expr *getCond() const { |
181 | 896 | return cast_or_null<Expr>(SubExprs[COND]); |
182 | 896 | } |
183 | 530 | const Expr *getInc() const { |
184 | 530 | return cast_or_null<Expr>(SubExprs[INC]); |
185 | 530 | } |
186 | 350 | const DeclStmt *getLoopVarStmt() const { |
187 | 350 | return cast<DeclStmt>(SubExprs[LOOPVAR]); |
188 | 350 | } |
189 | 646 | const Stmt *getBody() const { return SubExprs[BODY]; } |
190 | | |
191 | 216 | void setInit(Stmt *S) { SubExprs[INIT] = S; } |
192 | 0 | void setRangeInit(Expr *E) { SubExprs[RANGE] = reinterpret_cast<Stmt*>(E); } |
193 | 216 | void setRangeStmt(Stmt *S) { SubExprs[RANGE] = S; } |
194 | 216 | void setBeginStmt(Stmt *S) { SubExprs[BEGINSTMT] = S; } |
195 | 216 | void setEndStmt(Stmt *S) { SubExprs[ENDSTMT] = S; } |
196 | 216 | void setCond(Expr *E) { SubExprs[COND] = reinterpret_cast<Stmt*>(E); } |
197 | 216 | void setInc(Expr *E) { SubExprs[INC] = reinterpret_cast<Stmt*>(E); } |
198 | 216 | void setLoopVarStmt(Stmt *S) { SubExprs[LOOPVAR] = S; } |
199 | 1.52k | void setBody(Stmt *S) { SubExprs[BODY] = S; } |
200 | | |
201 | 461 | SourceLocation getForLoc() const { return ForLoc; } |
202 | 381 | SourceLocation getCoawaitLoc() const { return CoawaitLoc; } |
203 | 407 | SourceLocation getColonLoc() const { return ColonLoc; } |
204 | 1.69k | SourceLocation getRParenLoc() const { return RParenLoc; } |
205 | | |
206 | 4.10k | SourceLocation getBeginLoc() const LLVM_READONLY { return ForLoc; } |
207 | 747 | SourceLocation getEndLoc() const LLVM_READONLY { |
208 | 747 | return SubExprs[BODY]->getEndLoc(); |
209 | 747 | } |
210 | | |
211 | 272k | static bool classof(const Stmt *T) { |
212 | 272k | return T->getStmtClass() == CXXForRangeStmtClass; |
213 | 272k | } |
214 | | |
215 | | // Iterators |
216 | 703 | child_range children() { |
217 | 703 | return child_range(&SubExprs[0], &SubExprs[END]); |
218 | 703 | } |
219 | | |
220 | 0 | const_child_range children() const { |
221 | 0 | return const_child_range(&SubExprs[0], &SubExprs[END]); |
222 | 0 | } |
223 | | }; |
224 | | |
225 | | /// Representation of a Microsoft __if_exists or __if_not_exists |
226 | | /// statement with a dependent name. |
227 | | /// |
228 | | /// The __if_exists statement can be used to include a sequence of statements |
229 | | /// in the program only when a particular dependent name does not exist. For |
230 | | /// example: |
231 | | /// |
232 | | /// \code |
233 | | /// template<typename T> |
234 | | /// void call_foo(T &t) { |
235 | | /// __if_exists (T::foo) { |
236 | | /// t.foo(); // okay: only called when T::foo exists. |
237 | | /// } |
238 | | /// } |
239 | | /// \endcode |
240 | | /// |
241 | | /// Similarly, the __if_not_exists statement can be used to include the |
242 | | /// statements when a particular name does not exist. |
243 | | /// |
244 | | /// Note that this statement only captures __if_exists and __if_not_exists |
245 | | /// statements whose name is dependent. All non-dependent cases are handled |
246 | | /// directly in the parser, so that they don't introduce a new scope. Clang |
247 | | /// introduces scopes in the dependent case to keep names inside the compound |
248 | | /// statement from leaking out into the surround statements, which would |
249 | | /// compromise the template instantiation model. This behavior differs from |
250 | | /// Visual C++ (which never introduces a scope), but is a fairly reasonable |
251 | | /// approximation of the VC++ behavior. |
252 | | class MSDependentExistsStmt : public Stmt { |
253 | | SourceLocation KeywordLoc; |
254 | | bool IsIfExists; |
255 | | NestedNameSpecifierLoc QualifierLoc; |
256 | | DeclarationNameInfo NameInfo; |
257 | | Stmt *SubStmt; |
258 | | |
259 | | friend class ASTReader; |
260 | | friend class ASTStmtReader; |
261 | | |
262 | | public: |
263 | | MSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists, |
264 | | NestedNameSpecifierLoc QualifierLoc, |
265 | | DeclarationNameInfo NameInfo, |
266 | | CompoundStmt *SubStmt) |
267 | | : Stmt(MSDependentExistsStmtClass), |
268 | | KeywordLoc(KeywordLoc), IsIfExists(IsIfExists), |
269 | | QualifierLoc(QualifierLoc), NameInfo(NameInfo), |
270 | 12 | SubStmt(reinterpret_cast<Stmt *>(SubStmt)) { } |
271 | | |
272 | | /// Retrieve the location of the __if_exists or __if_not_exists |
273 | | /// keyword. |
274 | 10 | SourceLocation getKeywordLoc() const { return KeywordLoc; } |
275 | | |
276 | | /// Determine whether this is an __if_exists statement. |
277 | 14 | bool isIfExists() const { return IsIfExists; } |
278 | | |
279 | | /// Determine whether this is an __if_exists statement. |
280 | 6 | bool isIfNotExists() const { return !IsIfExists; } |
281 | | |
282 | | /// Retrieve the nested-name-specifier that qualifies this name, if |
283 | | /// any. |
284 | 46 | NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; } |
285 | | |
286 | | /// Retrieve the name of the entity we're testing for, along with |
287 | | /// location information |
288 | 22 | DeclarationNameInfo getNameInfo() const { return NameInfo; } |
289 | | |
290 | | /// Retrieve the compound statement that will be included in the |
291 | | /// program only if the existence of the symbol matches the initial keyword. |
292 | 12 | CompoundStmt *getSubStmt() const { |
293 | 12 | return reinterpret_cast<CompoundStmt *>(SubStmt); |
294 | 12 | } |
295 | | |
296 | 34 | SourceLocation getBeginLoc() const LLVM_READONLY { return KeywordLoc; } |
297 | 34 | SourceLocation getEndLoc() const LLVM_READONLY { |
298 | 34 | return SubStmt->getEndLoc(); |
299 | 34 | } |
300 | | |
301 | 4 | child_range children() { |
302 | 4 | return child_range(&SubStmt, &SubStmt+1); |
303 | 4 | } |
304 | | |
305 | 0 | const_child_range children() const { |
306 | 0 | return const_child_range(&SubStmt, &SubStmt + 1); |
307 | 0 | } |
308 | | |
309 | 14 | static bool classof(const Stmt *T) { |
310 | 14 | return T->getStmtClass() == MSDependentExistsStmtClass; |
311 | 14 | } |
312 | | }; |
313 | | |
314 | | /// Represents the body of a coroutine. This wraps the normal function |
315 | | /// body and holds the additional semantic context required to set up and tear |
316 | | /// down the coroutine frame. |
317 | | class CoroutineBodyStmt final |
318 | | : public Stmt, |
319 | | private llvm::TrailingObjects<CoroutineBodyStmt, Stmt *> { |
320 | | enum SubStmt { |
321 | | Body, ///< The body of the coroutine. |
322 | | Promise, ///< The promise statement. |
323 | | InitSuspend, ///< The initial suspend statement, run before the body. |
324 | | FinalSuspend, ///< The final suspend statement, run after the body. |
325 | | OnException, ///< Handler for exceptions thrown in the body. |
326 | | OnFallthrough, ///< Handler for control flow falling off the body. |
327 | | Allocate, ///< Coroutine frame memory allocation. |
328 | | Deallocate, ///< Coroutine frame memory deallocation. |
329 | | ReturnValue, ///< Return value for thunk function: p.get_return_object(). |
330 | | ResultDecl, ///< Declaration holding the result of get_return_object. |
331 | | ReturnStmt, ///< Return statement for the thunk function. |
332 | | ReturnStmtOnAllocFailure, ///< Return statement if allocation failed. |
333 | | FirstParamMove ///< First offset for move construction of parameter copies. |
334 | | }; |
335 | | unsigned NumParams; |
336 | | |
337 | | friend class ASTStmtReader; |
338 | | friend class ASTReader; |
339 | | friend TrailingObjects; |
340 | | |
341 | 291 | Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); } |
342 | | |
343 | 2.45k | Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); } |
344 | | |
345 | | public: |
346 | | |
347 | | struct CtorArgs { |
348 | | Stmt *Body = nullptr; |
349 | | Stmt *Promise = nullptr; |
350 | | Expr *InitialSuspend = nullptr; |
351 | | Expr *FinalSuspend = nullptr; |
352 | | Stmt *OnException = nullptr; |
353 | | Stmt *OnFallthrough = nullptr; |
354 | | Expr *Allocate = nullptr; |
355 | | Expr *Deallocate = nullptr; |
356 | | Expr *ReturnValue = nullptr; |
357 | | Stmt *ResultDecl = nullptr; |
358 | | Stmt *ReturnStmt = nullptr; |
359 | | Stmt *ReturnStmtOnAllocFailure = nullptr; |
360 | | ArrayRef<Stmt *> ParamMoves; |
361 | | }; |
362 | | |
363 | | private: |
364 | | |
365 | | CoroutineBodyStmt(CtorArgs const& Args); |
366 | | |
367 | | public: |
368 | | static CoroutineBodyStmt *Create(const ASTContext &C, CtorArgs const &Args); |
369 | | static CoroutineBodyStmt *Create(const ASTContext &C, EmptyShell, |
370 | | unsigned NumParams); |
371 | | |
372 | 47 | bool hasDependentPromiseType() const { |
373 | 47 | return getPromiseDecl()->getType()->isDependentType(); |
374 | 47 | } |
375 | | |
376 | | /// Retrieve the body of the coroutine as written. This will be either |
377 | | /// a CompoundStmt or a TryStmt. |
378 | 1.03k | Stmt *getBody() const { |
379 | 1.03k | return getStoredStmts()[SubStmt::Body]; |
380 | 1.03k | } |
381 | | |
382 | 209 | Stmt *getPromiseDeclStmt() const { |
383 | 209 | return getStoredStmts()[SubStmt::Promise]; |
384 | 209 | } |
385 | 156 | VarDecl *getPromiseDecl() const { |
386 | 156 | return cast<VarDecl>(cast<DeclStmt>(getPromiseDeclStmt())->getSingleDecl()); |
387 | 156 | } |
388 | | |
389 | 109 | Stmt *getInitSuspendStmt() const { |
390 | 109 | return getStoredStmts()[SubStmt::InitSuspend]; |
391 | 109 | } |
392 | 107 | Stmt *getFinalSuspendStmt() const { |
393 | 107 | return getStoredStmts()[SubStmt::FinalSuspend]; |
394 | 107 | } |
395 | | |
396 | 96 | Stmt *getExceptionHandler() const { |
397 | 96 | return getStoredStmts()[SubStmt::OnException]; |
398 | 96 | } |
399 | 140 | Stmt *getFallthroughHandler() const { |
400 | 140 | return getStoredStmts()[SubStmt::OnFallthrough]; |
401 | 140 | } |
402 | | |
403 | 65 | Expr *getAllocate() const { |
404 | 65 | return cast_or_null<Expr>(getStoredStmts()[SubStmt::Allocate]); |
405 | 65 | } |
406 | 102 | Expr *getDeallocate() const { |
407 | 102 | return cast_or_null<Expr>(getStoredStmts()[SubStmt::Deallocate]); |
408 | 102 | } |
409 | 47 | Expr *getReturnValueInit() const { |
410 | 47 | return cast<Expr>(getStoredStmts()[SubStmt::ReturnValue]); |
411 | 47 | } |
412 | 93 | Stmt *getResultDecl() const { return getStoredStmts()[SubStmt::ResultDecl]; } |
413 | 59 | Stmt *getReturnStmt() const { return getStoredStmts()[SubStmt::ReturnStmt]; } |
414 | 96 | Stmt *getReturnStmtOnAllocFailure() const { |
415 | 96 | return getStoredStmts()[SubStmt::ReturnStmtOnAllocFailure]; |
416 | 96 | } |
417 | 300 | ArrayRef<Stmt const *> getParamMoves() const { |
418 | 300 | return {getStoredStmts() + SubStmt::FirstParamMove, NumParams}; |
419 | 300 | } |
420 | | |
421 | 99 | SourceLocation getBeginLoc() const LLVM_READONLY { |
422 | 99 | return getBody() ? getBody()->getBeginLoc() |
423 | 0 | : getPromiseDecl()->getBeginLoc(); |
424 | 99 | } |
425 | 347 | SourceLocation getEndLoc() const LLVM_READONLY { |
426 | 347 | return getBody() ? getBody()->getEndLoc() : getPromiseDecl()->getEndLoc()0 ; |
427 | 347 | } |
428 | | |
429 | 21 | child_range children() { |
430 | 21 | return child_range(getStoredStmts(), |
431 | 21 | getStoredStmts() + SubStmt::FirstParamMove + NumParams); |
432 | 21 | } |
433 | | |
434 | 0 | const_child_range children() const { |
435 | 0 | return const_child_range(getStoredStmts(), getStoredStmts() + |
436 | 0 | SubStmt::FirstParamMove + |
437 | 0 | NumParams); |
438 | 0 | } |
439 | | |
440 | 3.97M | static bool classof(const Stmt *T) { |
441 | 3.97M | return T->getStmtClass() == CoroutineBodyStmtClass; |
442 | 3.97M | } |
443 | | }; |
444 | | |
445 | | /// Represents a 'co_return' statement in the C++ Coroutines TS. |
446 | | /// |
447 | | /// This statament models the initialization of the coroutine promise |
448 | | /// (encapsulating the eventual notional return value) from an expression |
449 | | /// (or braced-init-list), followed by termination of the coroutine. |
450 | | /// |
451 | | /// This initialization is modeled by the evaluation of the operand |
452 | | /// followed by a call to one of: |
453 | | /// <promise>.return_value(<operand>) |
454 | | /// <promise>.return_void() |
455 | | /// which we name the "promise call". |
456 | | class CoreturnStmt : public Stmt { |
457 | | SourceLocation CoreturnLoc; |
458 | | |
459 | | enum SubStmt { Operand, PromiseCall, Count }; |
460 | | Stmt *SubStmts[SubStmt::Count]; |
461 | | |
462 | | bool IsImplicit : 1; |
463 | | |
464 | | friend class ASTStmtReader; |
465 | | public: |
466 | | CoreturnStmt(SourceLocation CoreturnLoc, Stmt *Operand, Stmt *PromiseCall, |
467 | | bool IsImplicit = false) |
468 | | : Stmt(CoreturnStmtClass), CoreturnLoc(CoreturnLoc), |
469 | 248 | IsImplicit(IsImplicit) { |
470 | 248 | SubStmts[SubStmt::Operand] = Operand; |
471 | 248 | SubStmts[SubStmt::PromiseCall] = PromiseCall; |
472 | 248 | } |
473 | | |
474 | 3 | CoreturnStmt(EmptyShell) : CoreturnStmt({}, {}, {}) {} Unexecuted instantiation: clang::CoreturnStmt::CoreturnStmt(clang::Stmt::EmptyShell) clang::CoreturnStmt::CoreturnStmt(clang::Stmt::EmptyShell) Line | Count | Source | 474 | 3 | CoreturnStmt(EmptyShell) : CoreturnStmt({}, {}, {}) {} |
|
475 | | |
476 | 20 | SourceLocation getKeywordLoc() const { return CoreturnLoc; } |
477 | | |
478 | | /// Retrieve the operand of the 'co_return' statement. Will be nullptr |
479 | | /// if none was specified. |
480 | 139 | Expr *getOperand() const { return static_cast<Expr*>(SubStmts[Operand]); } |
481 | | |
482 | | /// Retrieve the promise call that results from this 'co_return' |
483 | | /// statement. Will be nullptr if either the coroutine has not yet been |
484 | | /// finalized or the coroutine has no eventual return type. |
485 | 55 | Expr *getPromiseCall() const { |
486 | 55 | return static_cast<Expr*>(SubStmts[PromiseCall]); |
487 | 55 | } |
488 | | |
489 | 20 | bool isImplicit() const { return IsImplicit; } |
490 | 0 | void setIsImplicit(bool value = true) { IsImplicit = value; } |
491 | | |
492 | 34 | SourceLocation getBeginLoc() const LLVM_READONLY { return CoreturnLoc; } |
493 | 15 | SourceLocation getEndLoc() const LLVM_READONLY { |
494 | 13 | return getOperand() ? getOperand()->getEndLoc()2 : getBeginLoc(); |
495 | 15 | } |
496 | | |
497 | 41 | child_range children() { |
498 | 41 | if (!getOperand()) |
499 | 21 | return child_range(SubStmts + SubStmt::PromiseCall, |
500 | 21 | SubStmts + SubStmt::Count); |
501 | 20 | return child_range(SubStmts, SubStmts + SubStmt::Count); |
502 | 20 | } |
503 | | |
504 | 0 | const_child_range children() const { |
505 | 0 | if (!getOperand()) |
506 | 0 | return const_child_range(SubStmts + SubStmt::PromiseCall, |
507 | 0 | SubStmts + SubStmt::Count); |
508 | 0 | return const_child_range(SubStmts, SubStmts + SubStmt::Count); |
509 | 0 | } |
510 | | |
511 | 420 | static bool classof(const Stmt *T) { |
512 | 420 | return T->getStmtClass() == CoreturnStmtClass; |
513 | 420 | } |
514 | | }; |
515 | | |
516 | | } // end namespace clang |
517 | | |
518 | | #endif |