Cpp.ExpressionStatement Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the expression_statement nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.ExpressionStatement represents the node expression_statement in the syntax tree of your code.

void test_expression_stmt() {
    int x = 0;
    x = 42;
    a = 1, b = 2;
    (void)printf("%d\n", x);
}

The function body contains several expression_statement nodes such as x = 42;, a = 1, b = 2; and the cast-expression statement (void)printf("%d\n", x); which correspond to Cpp.ExpressionStatement in PQL.

Predicates

expand all

Type

Type	Raisable	Printable
`ExpressionStatement`	Yes	No

Syntaxes

This class defines these predicates that act on the objects of this class. In addition, objects of this class can access the predicates defined by the base class AstNodeProperties. An object of this class is an object of AstNodeProperties class.

Predicates	Description	Example
`is(required ExpressionStatement &expressionStatement)`	Matches an `expression_statement` node and binds it to the output variable. Use this to obtain the node itself for further predicates.	This PQL defect checks for any expression statement node and reports its text. defect check_expr_stmt = when Cpp.ExpressionStatement.is(&exprStmt) and exprStmt.nodeText(&txt) raise "Found expression statement: \"{txt}\"" on exprStmt In this C++ code the defect finds each top-level expression statement inside the function body. #include <cstdio> void f() { int x = 0; x = 42; } int main() { f(); return 0; }
`cast(Cpp.Node.Node node, required ExpressionStatement &cast)`	Checks whether a given `Node` is an `expression_statement` and if so binds that node to the output `cast`.	This PQL defect checks whether an arbitrary `Node` is an `expression_statement` by attempting a cast. defect check_cast = when Cpp.Node.is(&n, &,&,&) and Cpp.ExpressionStatement.cast(n, &exprStmt) and exprStmt.nodeText(&txt) raise "Node cast to expression_statement: \"{txt}\"" on exprStmt In this C++ code the defect checks nodes discovered generically and reports those that are expression statements such as `x = 42;`. #include <cstdio> void f() { int x; x = 42; } int main() { f(); return 0; }
`isa(Cpp.Node.Node node)`	Returns true when the given `Node` is an `expression_statement`. Use it for boolean checks or negations.	This PQL defect checks nodes with a boolean test to find expression statements. defect check_isa = when Cpp.Node.is(&n, &,&,&) and Cpp.ExpressionStatement.isa(n) and n.nodeText( &txt) raise "Node is an expression_statement: \"{txt}\"" on n In this C++ example the defect finds `x = 42;` by testing generic nodes with `isa`. #include <cstdio> void g() { int x; x = 42; } int main() { g(); return 0; }
`expression(ExpressionStatement self, Cpp.Node.Node &child)`	Matches the subnode that is the expression inside an `expression_statement` and binds it to `child`.	This PQL defect checks for expression statements and extracts their contained expression. defect check_expression = when Cpp.ExpressionStatement.is(&stmt) and stmt.expression(&expr) and expr.nodeText(&txt) raise "Expression statement contains: \"{txt}\"" on stmt In this C++ code the defect extracts the inner expressions like `x = 42` from the statement `x = 42;`. #include <cstdio> void h() { int x; x = 42; } int main() { h(); return 0; }
`commaExpression(ExpressionStatement self, Cpp.Node.Node &child)`	Matches the comma expression used as the statement's expression and binds that comma-expression node.	This PQL defect checks for expression statements whose expression is a comma expression such as `a = 1, b = 2`. defect check_comma_expr = when Cpp.ExpressionStatement.is(&stmt) and stmt.commaExpression(&comma) and comma.nodeText(&txt) raise "Comma expression statement: \"{txt}\"" on stmt In this C++ example the defect finds the `a = 1, b = 2;` statement and reports the comma expression. #include <cstdio> void k() { int a = 0, b = 0; a = 1, b = 2; } int main() { k(); return 0; }
`getEnclosingExpressionStatement(Cpp.Node.Node child, required ExpressionStatement &parent)`	Finds the nearest enclosing `expression_statement` ancestor of the provided `child` node and binds it to `parent`.	This PQL defect checks for nodes inside an expression and reports their enclosing expression statement. defect check_enclosing_expr_stmt = when Cpp.Node.is(&inner, &,&,&) and Cpp.ExpressionStatement.getEnclosingExpressionStatement(inner, &stmt) and stmt.nodeText(&txt) raise "Enclosing expression statement: \"{txt}\"" on stmt In this C++ example the defect locates the `printf` call node and reports the surrounding statement `(void)printf(...);`. #include <cstdio> void m() { (void)printf("%d\n", 1); } int main() { m(); return 0; }
`isEnclosedInExpressionStatement(Cpp.Node.Node child)`	Returns true when the given `child` has an `expression_statement` as an ancestor.	This PQL defect checks whether a node lies inside any expression statement. defect check_is_enclosed = when Cpp.Node.is(&n, &,&,&) and Cpp.ExpressionStatement.isEnclosedInExpressionStatement(n) and n.nodeText(n, &txt) raise "Node is enclosed in expression statement: \"{txt}\"" on n In this C++ example the defect detects the `printf` call node as being enclosed by the expression statement `(void)printf(...);`. #include <cstdio> void p() { (void)printf("%d\n", 1); } int main() { p(); return 0; }

Version History

Introduced in R2026a