Cpp.AssignmentExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the assignment_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class AssignmentExpression represents the node assignment_expression in the syntax tree of your code.

// demo.cpp
#include <vector>
int main() {
    int a = 0;
    int b = 1;
    a = b + 1;
    b += 2;
    a *= b;
    int arr[4];
    arr[1] = 5;
    return a;
}

The C++ demo contains several assignment_expression occurrences such as a = b + 1, b += 2, a *= b, and arr[1] = 5, each corresponding to the assignment_expression node.

Predicates

Type

Type	Raisable	Printable
AssignmentExpression	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 AssignmentExpression &ae)	Checks whether there exists an assignment_expression node and returns it as ae for further inspection.	This PQL defect checks for any assignment_expression nodes in the file. defect DetectAnyAssignment = when Cpp.AssignmentExpression.is(&ae) and ae.nodeText(&txt) raise "Found assignment: \"{txt}\"" on ae In this C++ code, the defect finds any assignment statements like simple, compound, or subscript assignments. #include <vector> int main() { int a = 0; a = 5; // detected a += 2; // detected return 0; }
cast(Cpp.Node.Node node, required AssignmentExpression &cast)	Interprets a generic Node as an assignment_expression; returns cast when the node is an assignment expression.	This PQL defect checks whether a generic node is an assignment_expression and then inspects it. defect cast_node_to_assignment = when Cpp.Node.is(&n, &,&,&) and Cpp.AssignmentExpression.cast(n, &ae) and ae.nodeText(&txt) raise "Casted node is assignment: \"{txt}\"" on ae In this C++ code, the defect checks a generic node that can be cast to an assignment expression. int main() { int a = 1; int b = 2; a = b + 1; return a; }
isa(Cpp.Node.Node node)	Determines whether a given Node is an assignment_expression; useful for boolean checks or negation.	This PQL defect checks whether a node is an assignment_expression and flags non-assignments. defect node_is_assignment = when Cpp.Node.is(&n, &,&,&) and Cpp.AssignmentExpression.isa(n) raise "Node is an assignment expression" on n In this C++ code, the predicate identifies b += 2 and arr[1] = 7 as assignment-expression nodes. int main() { int a = 0, b = 0; b += 2; int arr[3]; arr[1] = 7; return 0; }
left(AssignmentExpression self, Cpp.Node.Node &child)	Returns the left-hand side subnode of an assignment expression (the target being assigned).	This PQL defect checks for the left-hand side (LHS) of assignment expressions. defect check_assignment_left = when Cpp.AssignmentExpression.is(&ae) and ae.left(&lhs) and lhs.nodeText(&txt) raise "Assignment LHS: \"{txt}\"" on ae In this C++ code, the defect extracts LHS like a, b, and arr[1] from assignments. int main() { int a = 0; int b = 1; a = b + 1; b += 3; int arr[2]; arr[1] = 4; return 0; }
operator(AssignmentExpression self, Cpp.Node.Node &child)	Returns the assignment operator token node, e.g., =, +=, *=, etc., from the assignment expression.	This PQL defect checks which assignment operator is used in each assignment expression. defect check_assignment_operator = when Cpp.AssignmentExpression.is(&ae) and ae.operator(&op) and op.nodeText(&txt) raise "Assignment operator: \"{txt}\"" on ae In this C++ code, the defect finds operators like =, +=, and *= in assignments. int main() { int a = 0; a = 1; a += 2; a *= 3; return a; }
right(AssignmentExpression self, Cpp.Node.Node &child)	Returns the right-hand side subnode of an assignment expression (the value or expression assigned).	This PQL defect checks the right-hand side (RHS) expressions of assignments. defect check_assignment_right = when Cpp.AssignmentExpression.is(&ae) and ae.right(&rhs) and rhs.nodeText(&txt) raise "Assignment RHS: \"{txt}\"" on ae In this C++ code, the defect inspects RHS expressions like b + 1, 2, and z. int main() { int b = 1, z = 3; int a; a = b + 1; b = 2; a *= z; return a; }
getEnclosingAssignmentExpression(Cpp.Node.Node child, required AssignmentExpression &parent)	Finds the nearest ancestor assignment_expression that contains the given child node and returns it as parent.	This PQL defect checks for the closest assignment expression that surrounds a given node. defect find_enclosing_assignment = when Cpp.Node.is(&n, &,&,&) and Cpp.AssignmentExpression.getEnclosingAssignmentExpression(n, &ae) and ae.nodeText(&txt) raise "Enclosing assignment: \"{txt}\"" on ae In this C++ code, the defect locates a = b + 1 as the enclosing assignment for the b identifier node. int main() { int a = 0, b = 2; a = b + 1; return 0; }
isEnclosedInAssignmentExpression(Cpp.Node.Node child)	Returns true when the given node has any assignment_expression ancestor.	This PQL defect checks whether a node appears inside an assignment expression anywhere above it. defect node_inside_assignment = when Cpp.Node.is(&n, &,&,&) and Cpp.AssignmentExpression.isEnclosedInAssignmentExpression(n) raise "Node is inside an assignment expression" on n In this C++ code, the predicate matches the all child nodes of the assignment expression.. int main() { int a = 0, b = 1; a = b + 1; return 0; }

Version History

Introduced in R2026a