Cpp.ForStatement Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the for_statement nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.ForStatement represents the node for_statement in the syntax tree of your code.

void example() {
    for (int i = 0; i < 10; ++i) {
        // loop body
    }
}

The for (int i = 0; i < 10; ++i) { ... } statement is a for_statement node that Cpp.ForStatement models.

Predicates

expand all

Type

Type	Raisable	Printable
`ForStatement`	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 ForStatement &forStatement)`	Matches a `for_statement` node and binds it to `forStatement` for further queries.	This PQL defect checks for any `for_statement` node in the code. defect FindFor = when Cpp.ForStatement.is(&forStmt) and forStmt.nodeText(&txt) raise "Found for: \"{txt}\"" on forStmt In this C++ code, the defect finds the top-level `for` loop construct. int main() { for (int i = 0; i < 3; ++i) { } return 0; }
`cast(Cpp.Node.Node node, required ForStatement &cast)`	Checks whether a `Cpp.Node.node` is a `for_statement` and if so binds it as `cast` for using `ForStatement` predicates.	This PQL defect checks for a `for_statement` by converting a different syntax node to `Node` and then casting. defect CastToFor = when Cpp.Node.is(&node,&,&,&) and Cpp.ForStatement.cast(node, &forStmt) and forStmt.nodeText(&txt) raise "Casted node is for: \"{txt}\"" on forStmt In this C++ code, the defect looks for a `for` loop . void f() { for (int i = 0; i < 1; ++i) {} }
`isa(Cpp.Node.Node node)`	Checks whether a `Cpp.Node.node` is a `for_statement` returning true or allowing negation.	This PQL defect checks whether a converted node is a `for_statement` and flags when it is not. defect NotAFor = when Cpp.Node.is(&node,&,&,&) and not Cpp.ForStatement.isa(node) raise "Node is not a for_statement" on exprStmt In this C++ code, the defect finds syntax nodes that are not a `for` loop . void g() { int x = 0; }
`initializer(ForStatement self, Cpp.Node.Node &child)`	Returns the initializer part of a `for` loop such as a declaration or expression as `child`.	This PQL defect checks for a `for_statement` that has an initializer and captures its text. defect ForHasInit = when Cpp.ForStatement.is(&forStmt) and forStmt.initializer(&init) and init.nodeText(&txt) raise "For initializer: \"{txt}\"" on forStmt In this C++ code, the defect finds the `int i = 0` initializer of the `for` loop. void h() { for (int i = 0; i < 2; ++i) { } }
`condition(ForStatement self, Cpp.Node.Node &child)`	Returns the loop condition expression of a `for` loop as `child`.	This PQL defect checks for a `for_statement` and captures its condition expression. defect ForHasCond = when Cpp.ForStatement.is(&forStmt) and forStmt.condition(&cond) and cond.nodeText(&txt) raise "For condition: \"{txt}\"" on forStmt In this C++ code, the defect finds the `i < 10` condition inside the `for` loop. void k() { for (int i = 0; i < 10; ++i) { } }
`update(ForStatement self, Cpp.Node.Node &child)`	Returns the update expression of a `for` loop such as `++i` or `i++` as `child`.	This PQL defect checks for the update expression of a `for_statement`. defect ForHasUpdate = when Cpp.ForStatement.is(&forStmt) and forStmt.update(&upd) and upd.nodeText(&txt) raise "For update: \"{txt}\"" on forStmt In this C++ code, the defect captures the `++i` update in the `for` loop. void m() { for (int i = 0; i < 5; ++i) { } }
`body(ForStatement self, Cpp.Node.Node &child)`	Returns the loop body of the `for_statement` which may be a compound statement or a single statement as `child`.	This PQL defect checks for the body of a `for_statement` and reports its text. defect ForHasBody = when Cpp.ForStatement.is(&forStmt) and forStmt.body(&body) and body.nodeText(&txt) raise "For body: \"{txt}\"" on forStmt In this C++ code, the defect finds the `{ /* body */ }` block that is the loop body. void n() { for (int i = 0; i < 2; ++i) { int x = i; } }
`getEnclosingForStatement(Cpp.Node.Node child, required ForStatement &parent)`	Finds the nearest enclosing `for_statement` ancestor of the given `child` node and returns it as `parent`.	This PQL defect checks for the closest enclosing `for_statement` around a given inner node by first converting a different node to `Node`. defect EnclosingFor = when Cpp.ReturnStatement.is(&ret) and ret.toNode(&node) and Cpp.ForStatement.getEnclosingForStatement(node, &forParent) and forParent.nodeText(&txt) raise "Enclosing for: \"{txt}\"" on forParent In this C++ code, the defect finds the nearest `for` loop that encloses a `return` statement inside its body. int foo() { for (int i = 0; i < 3; ++i) { if (i == 1) return 42; } return 0; }
`isEnclosedInForStatement(Cpp.Node.Node child)`	Checks whether the given `child` node has a `for_statement` as an ancestor and returns true if so.	This PQL defect checks whether a node is inside any `for_statement` by converting a node to `Node` first. defect InsideFor = when Cpp.BreakStatement.is(&brk) and brk.toNode(&node) and Cpp.ForStatement.isEnclosedInForStatement(node) raise "Break is inside a for" on brk In this C++ code, the defect identifies a `break` statement that lives inside a `for` loop. void p() { for (;;) { break; } }

Version History

Introduced in R2026a