/**

* Provides a hierarchy of classes for modeling C/C++ statements.

*/

import semmle.code.cpp.Element

private import semmle.code.cpp.Enclosing

private import semmle.code.cpp.internal.ResolveClass

/**

* A C/C++ statement.

*/

class Stmt extends StmtParent, @stmt {

/** Gets the `n`th child of this statement. */

Element getChild(int n) {

stmtparents(unresolveElement(result), n, underlyingElement(this)) or

exprparents(unresolveElement(result), n, underlyingElement(this))

}

/** Holds if `e` is the `n`th child of this statement. */

predicate hasChild(Element e, int n) { this.getChild(n) = e }

/** Gets the enclosing function of this statement, if any. */

Function getEnclosingFunction() { result = stmtEnclosingElement(this) }

/**

* Gets the nearest enclosing block of this statement in the source, if any.

*/

BlockStmt getEnclosingBlock() {

if

this.getParentStmt() instanceof BlockStmt and

not this.getParentStmt().(BlockStmt).getLocation() instanceof UnknownLocation

then result = this.getParentStmt()

else result = this.getParentStmt().getEnclosingBlock()

}

/** Gets a child of this statement. */

Element getAChild() { result = this.getChild(_) }

/** Gets the parent of this statement, if any. */

StmtParent getParent() { stmtparents(underlyingElement(this), _, unresolveElement(result)) }

/** Gets the parent statement of this statement, if any. */

Stmt getParentStmt() { stmtparents(underlyingElement(this), _, unresolveElement(result)) }

/** Gets a child statement of this statement. */

Stmt getChildStmt() { result.getParentStmt() = this }

/**

* Gets the statement following this statement in the same block, if any.

*

* Note that this is not widely useful, because this doesn't have a result for

* the last statement of a block. Consider using the `ControlFlowNode` class

* to trace the flow of control instead.

*/

Stmt getFollowingStmt() {

exists(BlockStmt b, int i |

this = b.getStmt(i) and

result = b.getStmt(i + 1)

)

}

/**

* Gets the `n`th compiler-generated destructor call that is performed after this statement, in

* order of destruction.

*

* For instance, in the following code, `getImplicitDestructorCall(0)` for the block will be the

* destructor call for `c2`:

* ```cpp

* {

* MyClass c1;

* MyClass c2;

* }

* ```

*/

DestructorCall getImplicitDestructorCall(int n) {

synthetic_destructor_call(this, max(int i | synthetic_destructor_call(this, i, _)) - n, result)

}

/**

* Gets a compiler-generated destructor call that is performed after this statement.

*/

DestructorCall getAnImplicitDestructorCall() { synthetic_destructor_call(this, _, result) }

override Location getLocation() { stmts(underlyingElement(this), _, result) }

override string toString() { none() }

override Function getControlFlowScope() { result = this.getEnclosingFunction() }

override Stmt getEnclosingStmt() { result = this }

/**

* Holds if this statement is side-effect free (a conservative

* approximation; that is, it may be side-effect free even if this

* predicate doesn't hold).

*

* This predicate cannot be overridden; override `mayBeImpure()`

* instead.

*

* Note that this predicate only considers whether the statement has

* any side-effects, such as writing to a file. Even if it holds, the

* statement may be impure in the sense that its behavior is affected

* by external factors, such as the contents of global variables.

*/

final predicate isPure() { not this.mayBeImpure() }

/**

* Holds if it is possible that this statement is impure. If we are not

* sure, then it holds.

*/

predicate mayBeImpure() { any() }

/**

* Holds if it is possible that this statement is globally impure.

*

* Similar to `mayBeImpure()`, except that `mayBeGloballyImpure()`

* does not consider modifications to temporary local variables to be

* impure. That is, if you call a function in which

* `mayBeGloballyImpure()` doesn't hold for any statement, then the

* function as a whole will have no side-effects, even if it mutates

* its own fresh stack variables.

*/

predicate mayBeGloballyImpure() { any() }

/**

* Gets an attribute of this statement, for example

* `[[clang::fallthrough]]`.

*/

Attribute getAnAttribute() { stmtattributes(underlyingElement(this), unresolveElement(result)) }

/**

* Gets a macro invocation that generates this entire statement.

*

* For example, given

* ```

* #define SOMEFUN a()

* #define FOO do { SOMEFUN; b(); } while (0)

* void f(void) {

* FOO;

* }

* ```

* this predicate would have results of `SOMEFUN` and `FOO` for the

* function call `a()`, and just `FOO` for the function call `b()`,

* the block within the 'do' statement, and the entire 'do' statement.

*

* Note that, unlike `isInMacroExpansion()` it is not necessary for

* the macro to generate the terminating semi-colon.

*/

MacroInvocation getGeneratingMacro() { result.getAnExpandedElement() = this }

/** Holds if this statement was generated by the compiler. */

predicate isCompilerGenerated() { compgenerated(underlyingElement(this)) }

}

private class TStmtParent = @stmt or @expr;

/**

* An element that is the parent of a statement in the C/C++ AST.

*

* This is normally a statement, but may be a `StmtExpr`.

*/

class StmtParent extends ControlFlowNode, TStmtParent { }

/**

* A C/C++ 'expression' statement.

*

* For example,

* ```

* x = 1;

* ```

* is an assignment expression inside an 'expression' statement.

*/

class ExprStmt extends Stmt, @stmt_expr {

override string getAPrimaryQlClass() { result = "ExprStmt" }

/**

* Gets the expression of this 'expression' statement.

*

* For example, for

* ```

* x = 1;

* ```

* the result would be an `AssignExpr`.

*/

Expr getExpr() { result = this.getChild(0) }

override string toString() { result = "ExprStmt" }

override predicate mayBeImpure() { this.getExpr().mayBeImpure() }

override predicate mayBeGloballyImpure() { this.getExpr().mayBeGloballyImpure() }

override MacroInvocation getGeneratingMacro() {

// We only need the expression to be in the macro, not the semicolon.

result.getAnExpandedElement() = this.getExpr()

}

}

private class TControlStructure = TConditionalStmt or TLoop;

/**

* A C/C++ control structure, that is, either a conditional statement or

* a loop.

*/

class ControlStructure extends Stmt, TControlStructure {

/**

* Gets the controlling expression of this control structure.

*

* This is the condition of 'if' statements and loops, and the

* switched expression for 'switch' statements.

*/

Expr getControllingExpr() { none() } // overridden by subclasses

/** Gets a child declaration of this scope. */

Declaration getADeclaration() { none() }

}

private class TConditionalStmt = @stmt_if or @stmt_constexpr_if or @stmt_switch;

/**

* A C/C++ conditional statement, that is, either an 'if' statement or a

* 'switch' statement.

*/

class ConditionalStmt extends ControlStructure, TConditionalStmt { }

/**

* A C/C++ 'if' statement. For example, the `if` statement in the following

* code:

* ```

* if (x == 1) {

* ...

* }

* ```

*/

class IfStmt extends ConditionalStmt, @stmt_if {

override string getAPrimaryQlClass() { result = "IfStmt" }

/**

* Gets the initialization statement of this 'if' statement, if any.

*

* For example, for

* ```

* if (int x = y; b) { f(); }

* ```

* the result is `int x = y;`.

*

* Does not hold if the initialization statement is missing or an empty statement, as in

* ```

* if (b) { f(); }

* ```

* or

* ```

* if (; b) { f(); }

* ```

*/

Stmt getInitialization() { if_initialization(underlyingElement(this), unresolveElement(result)) }

/**

* Gets the condition expression of this 'if' statement.

*

* For example, for

* ```

* if (b) { x = 1; }

* ```

* the result is `b`.

*/

Expr getCondition() { result = this.getChild(1) }

override Expr getControllingExpr() { result = this.getCondition() }

/**

* Gets the 'then' statement of this 'if' statement.

*

* For example, for

* ```

* if (b) { x = 1; }

* ```

* the result is the `BlockStmt` `{ x = 1; }`.

*/

Stmt getThen() { if_then(underlyingElement(this), unresolveElement(result)) }

/**

* Gets the 'else' statement of this 'if' statement, if any.

*

* For example, for

* ```

* if (b) { x = 1; } else { x = 2; }

* ```

* the result is the `BlockStmt` `{ x = 2; }`, and for

* ```

* if (b) { x = 1; }

* ```

* there is no result.

*/

Stmt getElse() { if_else(underlyingElement(this), unresolveElement(result)) }

/**

* Holds if this 'if' statement has an 'else' statement.

*

* For example, this holds for

* ```

* if (b) { x = 1; } else { x = 2; }

* ```

* but not for

* ```

* if (b) { x = 1; }

* ```

*/

predicate hasElse() { exists(this.getElse()) }

override string toString() { result = "if (...) ... " }

override predicate mayBeImpure() {

this.getCondition().mayBeImpure() or

this.getThen().mayBeImpure() or

this.getElse().mayBeImpure()

}

override predicate mayBeGloballyImpure() {

this.getCondition().mayBeGloballyImpure() or

this.getThen().mayBeGloballyImpure() or

this.getElse().mayBeGloballyImpure()

}

override MacroInvocation getGeneratingMacro() {

result.getAnExpandedElement() = this.getCondition() and

this.getThen().getGeneratingMacro() = result and

(this.hasElse() implies this.getElse().getGeneratingMacro() = result)

}

}

/**

* A C/C++ 'constexpr if' statement. For example, the `if constexpr` statement

* in the following code:

* ```

* if constexpr (x) {

* ...

* }

* ```

*/

class ConstexprIfStmt extends ConditionalStmt, @stmt_constexpr_if {

override string getAPrimaryQlClass() { result = "ConstexprIfStmt" }

/**

* Gets the initialization statement of this 'constexpr if' statement, if any.

*

* For example, for

* ```

* if constexpr (int x = y; b) { f(); }

* ```

* the result is `int x = y;`.

*

* Does not hold if the initialization statement is missing or an empty statement, as in

* ```

* if constexpr (b) { f(); }

* ```

* or

* ```

* if constexpr (; b) { f(); }

* ```

*/

Stmt getInitialization() {

constexpr_if_initialization(underlyingElement(this), unresolveElement(result))

}

/**

* Gets the condition expression of this 'constexpr if' statement.

*

* For example, for

* ```

* if constexpr (b) { x = 1; }

* ```

* the result is `b`.

*/

Expr getCondition() { result = this.getChild(1) }

override Expr getControllingExpr() { result = this.getCondition() }

/**

* Gets the 'then' statement of this 'constexpr if' statement.

*

* For example, for

* ```

* if constexpr (b) { x = 1; }

* ```

* the result is the `BlockStmt` `{ x = 1; }`.

*/

Stmt getThen() { constexpr_if_then(underlyingElement(this), unresolveElement(result)) }

/**

* Gets the 'else' statement of this 'constexpr if' statement, if any.

*

* For example, for

* ```

* if constexpr (b) { x = 1; } else { x = 2; }

* ```

* the result is the `BlockStmt` `{ x = 2; }`, and for

* ```

* if constexpr (b) { x = 1; }

* ```

* there is no result.

*/

Stmt getElse() { constexpr_if_else(underlyingElement(this), unresolveElement(result)) }

/**

* Holds if this 'constexpr if' statement has an 'else' statement.

*

* For example, this holds for

* ```

* if constexpr (b) { x = 1; } else { x = 2; }

* ```

* but not for

* ```

* if constexpr (b) { x = 1; }

* ```

*/

predicate hasElse() { exists(this.getElse()) }

override string toString() { result = "if constexpr (...) ... " }

override predicate mayBeImpure() {

this.getCondition().mayBeImpure() or

this.getThen().mayBeImpure() or

this.getElse().mayBeImpure()

}

override predicate mayBeGloballyImpure() {

this.getCondition().mayBeGloballyImpure() or

this.getThen().mayBeGloballyImpure() or

this.getElse().mayBeGloballyImpure()

}

override MacroInvocation getGeneratingMacro() {

result.getAnExpandedElement() = this.getCondition() and

this.getThen().getGeneratingMacro() = result and

(this.hasElse() implies this.getElse().getGeneratingMacro() = result)

}

}

/**

* A C/C++ '(not) consteval if'. For example, the `if consteval` statement

* in the following code:

* ```cpp

* if consteval {

* ...

* }

* ```

*/

class ConstevalIfStmt extends Stmt, @stmt_consteval_or_not_consteval_if {

override string getAPrimaryQlClass() { result = "ConstevalIfStmt" }

override string toString() {

if this.isNot() then result = "if ! consteval ..." else result = "if consteval ..."

}

/**

* Holds if this is a 'not consteval if' statement.

*

* For example, this holds for

* ```cpp

* if ! consteval { return true; }

* ```

* but not for

* ```cpp

* if consteval { return true; }

* ```

*/

predicate isNot() { this instanceof @stmt_not_consteval_if }

/**

* Gets the 'then' statement of this '(not) consteval if' statement.

*

* For example, for

* ```cpp

* if consteval { return true; }

* ```

* the result is the `BlockStmt` `{ return true; }`.

*/

Stmt getThen() { consteval_if_then(underlyingElement(this), unresolveElement(result)) }

/**

* Gets the 'else' statement of this '(not) constexpr if' statement, if any.

*

* For example, for

* ```cpp

* if consteval { return true; } else { return false; }

* ```

* the result is the `BlockStmt` `{ return false; }`, and for

* ```cpp

* if consteval { return true; }

* ```

* there is no result.

*/

Stmt getElse() { consteval_if_else(underlyingElement(this), unresolveElement(result)) }

/**

* Holds if this '(not) constexpr if' statement has an 'else' statement.

*

* For example, this holds for

* ```cpp

* if consteval { return true; } else { return false; }

* ```

* but not for

* ```cpp

* if consteval { return true; }

* ```

*/

predicate hasElse() { exists(this.getElse()) }

override predicate mayBeImpure() {

this.getThen().mayBeImpure() or

this.getElse().mayBeImpure()

}

override predicate mayBeGloballyImpure() {

this.getThen().mayBeGloballyImpure() or

this.getElse().mayBeGloballyImpure()

}

override MacroInvocation getGeneratingMacro() {

this.getThen().getGeneratingMacro() = result and

(this.hasElse() implies this.getElse().getGeneratingMacro() = result)

}

/**

* Gets the statement of this '(not) consteval if' statement evaluated during compile time, if any.

*

* For example, for

* ```cpp

* if ! consteval { return true; } else { return false; }

* ```

* the result is the `BlockStmt` `{ return false; }`, and for

* ```cpp

* if ! consteval { return true; }

* ```

* there is no result.

*/

Stmt getCompileTimeEvaluatedBranch() {

if this.isNot() then result = this.getElse() else result = this.getThen()

}

/**

* Holds if this '(not) constexpr if' statement has a compile time evaluated statement.

*

* For example, this holds for

* ```cpp

* if ! consteval { return true; } else { return false; }

* ```

* but not for

* ```cpp

* if ! consteval { return true; }

* ```

*/

predicate hasCompileTimeEvaluatedBranch() { exists(this.getCompileTimeEvaluatedBranch()) }

/**

* Gets the statement of this '(not) consteval if' statement evaluated during runtime, if any.

*

* For example, for

* ```cpp

* if consteval { return true; } else { return false; }

* ```

* the result is the `BlockStmt` `{ return false; }`, and for

* ```cpp

* if consteval { return true; }

* ```

* there is no result.

*/

Stmt getRuntimeEvaluatedBranch() {

if this.isNot() then result = this.getThen() else result = this.getElse()

}

/**

* Holds if this '(not) constexpr if' statement has a runtime evaluated statement.

*

* For example, this holds for

* ```cpp

* if consteval { return true; } else { return false; }

* ```

* but not for

* ```cpp

* if consteval { return true; }

* ```

*/

predicate hasRuntimeEvaluatedBranch() { exists(this.getRuntimeEvaluatedBranch()) }

}

private class TLoop = @stmt_while or @stmt_end_test_while or @stmt_range_based_for or @stmt_for;

/**

* A C/C++ loop, that is, either a 'while' loop, a 'for' loop, or a

* 'do' loop.

*/

class Loop extends ControlStructure, TLoop {

/** Gets the condition expression of this loop. */

Expr getCondition() { none() } // overridden in subclasses

/** Gets the body statement of this loop. */

Stmt getStmt() { none() } // overridden in subclasses

}

/**

* A C/C++ 'while' statement.

*

* For example, the `while` statement in the following code:

* ```

* while (b) {

* f();

* }

* ```

*/

class WhileStmt extends Loop, @stmt_while {

override string getAPrimaryQlClass() { result = "WhileStmt" }

override Expr getCondition() { result = this.getChild(0) }

override Expr getControllingExpr() { result = this.getCondition() }

override Stmt getStmt() { while_body(underlyingElement(this), unresolveElement(result)) }

override string toString() { result = "while (...) ..." }

override predicate mayBeImpure() {

this.getCondition().mayBeImpure() or

this.getStmt().mayBeImpure()

}

override predicate mayBeGloballyImpure() {

this.getCondition().mayBeGloballyImpure() or

this.getStmt().mayBeGloballyImpure()

}

override MacroInvocation getGeneratingMacro() {

result.getAnExpandedElement() = this.getCondition() and

this.getStmt().getGeneratingMacro() = result

}

/**

* Holds if the loop condition is provably `true`.

*

* For example, this holds for

* ```

* while(1) { ...; if(b) break; ...; }

* ```

*/

predicate conditionAlwaysTrue() { conditionAlwaysTrue(this.getCondition()) }

/**

* Holds if the loop condition is provably `false`.

*

* For example, this holds for

* ```

* while(0) { ...; }

* ```

*/

predicate conditionAlwaysFalse() { conditionAlwaysFalse(this.getCondition()) }

/**

* Holds if the loop condition is provably `true` upon entry,

* that is, at least one iteration of the loop is guaranteed.

*

* For example, with

* ```

* bool done = false;

* while (!done) { ... done = true; ... }

* ```

* the condition `!done` always evaluates to `true` upon entry since

* `done = false`, but the condition may evaluate to `false` after

* some iterations.

*/

predicate conditionAlwaysTrueUponEntry() { loopConditionAlwaysTrueUponEntry(this, _) }

}

/**

* A C/C++ jump statement.

*/

class JumpStmt extends Stmt, @jump {

override string getAPrimaryQlClass() { result = "JumpStmt" }

/** Gets the target of this jump statement. */

Stmt getTarget() { jumpinfo(underlyingElement(this), _, unresolveElement(result)) }

}

/**

* A C/C++ 'goto' statement which jumps to a label.

*

* For example, the `goto` statement in the following code:

* ```

* goto someLabel;

* ...

* somelabel:

* ```

*/

class GotoStmt extends JumpStmt, @stmt_goto {

override string getAPrimaryQlClass() { result = "GotoStmt" }

/**

* Gets the name of the label this 'goto' statement refers to.

*

* For example, for

* ```

* goto someLabel;

* ```

* the result is `"someLabel"`.

*/

string getName() { jumpinfo(underlyingElement(this), result, _) and result != "" }

/** Holds if this 'goto' statement refers to a label. */

predicate hasName() { exists(string s | jumpinfo(underlyingElement(this), s, _) and s != "") }

override string toString() { result = "goto ..." }

/**

* Holds if this 'goto' statement breaks out of two or more nested

* loops.

*

* For example, for

* ```

* while(b) {

* while(b) {

* if(b) goto middle;

* if(b) goto end;

* }

* if(b) goto end;

* middle:

* }

* end:

* ```

* this holds for the second `goto`, but not the first or third.

*/

predicate breaksFromNestedLoops() {

exists(Loop l1, Loop l2 |

this.getParentStmt+() = l1 and

l1.getParentStmt+() = l2 and

l2.getParentStmt+() = this.getASuccessor().(Stmt).getParentStmt()

)

}

override predicate mayBeImpure() { none() }

override predicate mayBeGloballyImpure() { none() }

}

/**

* A 'goto' statement whose target is computed by a non-constant

* expression (a non-standard extension to C/C++).

*

* For example, the `goto` statement in the following code:

* ```

* goto *ptr;

* ```

*/

class ComputedGotoStmt extends Stmt, @stmt_assigned_goto {

/**

* Gets the expression used to compute the target of this 'goto'

* statement.

*

* For example, for

* ```

* goto *ptr;

* ```

* the result is `ptr`.

*/

Expr getExpr() { result = this.getChild(0) }

override string toString() { result = "computed goto ..." }

override predicate mayBeImpure() { this.getExpr().mayBeImpure() }

override predicate mayBeGloballyImpure() { this.getExpr().mayBeGloballyImpure() }

override MacroInvocation getGeneratingMacro() {

// We only need the expression to be in the macro, not the semicolon.

result.getAnExpandedElement() = this.getExpr()

}

}

/**

* A C/C++ 'continue' statement.

*

* For example, the `continue` statement in the following code:

* ```

* while (x) {

* if (arr[x] < 0) continue;

* ...

* }

* ```

*/

class ContinueStmt extends JumpStmt, @stmt_continue {

override string getAPrimaryQlClass() { result = "ContinueStmt" }

override string toString() { result = "continue;" }

override predicate mayBeImpure() { none() }

override predicate mayBeGloballyImpure() { none() }

/**

* Gets the loop that this continue statement will jump to the beginning of.

*/

Stmt getContinuable() { result = getEnclosingContinuable(this) }

}

private Stmt getEnclosingContinuable(Stmt s) {

if s.getParent().getEnclosingStmt() instanceof Loop

then result = s.getParent().getEnclosingStmt()

else result = getEnclosingContinuable(s.getParent().getEnclosingStmt())

}

/**

* A C/C++ 'break' statement.

*

* For example, the `break` statement in the following code:

* ```

* while (x) {

* if (arr[x] == 0) break;

* ...

* }

* ```

*/

class BreakStmt extends JumpStmt, @stmt_break {

override string getAPrimaryQlClass() { result = "BreakStmt" }

override string toString() { result = "break;" }

override predicate mayBeImpure() { none() }

override predicate mayBeGloballyImpure() { none() }

/**

* Gets the loop or switch statement that this break statement will exit.

*/

Stmt getBreakable() { result = getEnclosingBreakable(this) }

}

private Stmt getEnclosingBreakable(Stmt s) {

if

s.getParent().getEnclosingStmt() instanceof Loop or

s.getParent().getEnclosingStmt() instanceof SwitchStmt

then result = s.getParent().getEnclosingStmt()

else result = getEnclosingBreakable(s.getParent().getEnclosingStmt())

}

/**

* A C/C++ 'label' statement.

*

* For example, the `somelabel:` statement in the following code:

* ```

* goto someLabel;

* ...

* somelabel:

* ```

*/

class LabelStmt extends Stmt, @stmt_label {

override string getAPrimaryQlClass() { result = "LabelStmt" }

/** Gets the name of this 'label' statement. */

string getName() { jumpinfo(underlyingElement(this), result, _) and result != "" }

/** Holds if this 'label' statement is named. */

predicate isNamed() { exists(this.getName()) }

override string toString() { result = "label ...:" }

override predicate mayBeImpure() { none() }

override predicate mayBeGloballyImpure() { none() }

}

/**

* A C/C++ `co_return` statement.

*

* For example:

* ```

* co_return 1+2;

* ```

* or

* ```

* co_return;

* ```

*/

class CoReturnStmt extends Stmt, @stmt_co_return {

override string getAPrimaryQlClass() { result = "CoReturnStmt" }

/**

* Gets the operand of this `co_return` statement.

*

* For example, for

* ```

* co_return 1+2;

* ```

* the operand is a function call `return_value(1+2)`, and for

* ```

* co_return;

* ```

* the operand is a function call `return_void()`.

*/

FunctionCall getOperand() { result = this.getChild(0) }

/**

* Gets the expression of this `co_return` statement, if any.

*

* For example, for

* ```

* co_return 1+2;

* ```

* the result is `1+2`, and there is no result for

* ```

* co_return;

* ```

*/

Expr getExpr() { result = this.getOperand().getArgument(0) }

/**

* Holds if this `co_return` statement has an expression.

*

* For example, this holds for

* ```

* co_return 1+2;

* ```

* but not for

* ```

* co_return;

* ```

*/

predicate hasExpr() { exists(this.getExpr()) }

override string toString() { result = "co_return ..." }

}

/**

* A C/C++ 'return' statement.

*

* For example:

* ```

* return 1+2;

* ```

* or

* ```

* return;

* ```

*/

class ReturnStmt extends Stmt, @stmt_return {

override string getAPrimaryQlClass() { result = "ReturnStmt" }

/**

* Gets the expression of this 'return' statement.

*

* For example, for

* ```

* return 1+2;

* ```

* the result is `1+2`, and there is no result for

* ```

* return;

* ```

*/

Expr getExpr() { result = this.getChild(0) }

/**

* Holds if this 'return' statement has an expression.

*

* For example, this holds for

* ```

* return 1+2;

* ```

* but not for

* ```

* return;

* ```

*/

predicate hasExpr() { exists(this.getExpr()) }

override string toString() { result = "return ..." }

override predicate mayBeImpure() { this.getExpr().mayBeImpure() }

override predicate mayBeGloballyImpure() { this.getExpr().mayBeGloballyImpure() }

}

/**

* A C/C++ 'do' statement.

*

* For example, the `do` ... `while` in the following code:

* ```

* do {

* x = x + 1;

* } while (x < 10);

* ```

*/

class DoStmt extends Loop, @stmt_end_test_while {

override string getAPrimaryQlClass() { result = "DoStmt" }

override Expr getCondition() { result = this.getChild(0) }

override Expr getControllingExpr() { result = this.getCondition() }

override Stmt getStmt() { do_body(underlyingElement(this), unresolveElement(result)) }

override string toString() { result = "do (...) ..." }