Cpp.ParenthesizedExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the parenthesized_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.ParenthesizedExpression represents the node parenthesized_expression in the syntax tree of your code.

#define FOO
void test() {
    int a = (1 + 2);
    int b = (a, 3);
#if defined(FOO)
    int c = 1;
#endif
}

The examples show three parenthesized expressions: (1 + 2), (a, 3), and (FOO) where each corresponds to a parenthesized_expression PQL node.

Predicates

Type

Type	Raisable	Printable
ParenthesizedExpression	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 ParenthesizedExpression &pe)	Match any parenthesized_expression node and return it in &pe for further inspection.	This PQL defect checks for any parenthesized_expression in the code. defect defectIs = when Cpp.ParenthesizedExpression.is(&pe) and pe.nodeText(&txt) raise "ParenthesizedExpression.is matched: \"{txt}\"" on pe In this C++ code the defect finds every parenthesized expression such as arithmetic and comma expressions. void f() { int x = (1 + 2); int y = (x, 4); }
cast(Cpp.Node.Node node, required ParenthesizedExpression &cast)	Convert a generic Node to a ParenthesizedExpression when the node is actually a parenthesized_expression.	This PQL defect checks for child nodes of declaration nodes that can be converted to parenthesized_expression. defect defectCast = when Cpp.Declaration.is(&decl) and decl.getADescendant(&node) and Cpp.ParenthesizedExpression.cast(node, &cast) and cast.nodeText(&txt) raise "ParenthesizedExpression.cast matched: \"{txt}\"" on cast In this C++ code the defect converts a child node of a declaration node to a parenthesized_expression to report its text. void g() { int v = (2 * 3); }
isa(Cpp.Node.Node node)	Check whether a given Node represents a parenthesized_expression returning true or false.	This PQL defect checks whether a generic node is a parenthesized_expression. defect defectIsa = when Cpp.Declaration.is(&decl) and decl.getADescendant(&node) and Cpp.ParenthesizedExpression.isa(node) and pe.nodeText(&txt) raise "ParenthesizedExpression.isa matched: \"{txt}\"" on pe In this C++ code the defect verifies that a child node of a declaration is a parenthesized expression. void h() { int z = (5); }
expression(ParenthesizedExpression self, Cpp.Node.Node &child)	Return the inner expression node contained inside the parentheses such as an arithmetic expression.	This PQL defect checks for parenthesized_expression nodes and extracts the inner expression node. defect defectExpression = when Cpp.ParenthesizedExpression.is(&pe) and pe.expression(&expr) and expr.nodeText(&txt) raise "ParenthesizedExpression.expression matched: \"{txt}\"" on pe In this C++ code the defect finds the arithmetic expression inside (1 + 2). void i() { int a = (1 + 2); }
commaExpression(ParenthesizedExpression self, Cpp.Node.Node &child)	Return the inner comma expression node when the parentheses contain a comma-separated expression.	This PQL defect checks for parenthesized_expression nodes that contain a comma expression. defect defectCommaExpression = when Cpp.ParenthesizedExpression.is(&pe) and pe.commaExpression(&cexpr) and cexpr.nodeText(&txt) raise "ParenthesizedExpression.commaExpression matched: \"{txt}\"" on pe In this C++ code the defect finds the comma expression inside (a, 3). void j() { int a = 0; int b = (a, 3); }
preprocDefined(ParenthesizedExpression self, Cpp.Node.Node &child)	Match a parenthesized preprocessor defined expression and return the defined node.	This PQL defect checks for parenthesized preprocessor defined expressions such as (defined FOO). defect defectPreprocDefined = when Cpp.ParenthesizedExpression.is(&pe) and pe.preprocDefined(&ppd) and ppd.nodeText(&txt) raise "ParenthesizedExpression.preprocDefined matched: \"{txt}\"" on pe In this C++ code the defect finds the (defined FOO) preprocessor expression. #define FOO #if (defined FOO) int k = 1; #endif
getEnclosingParenthesizedExpression(Cpp.Node.Node child, required ParenthesizedExpression &parent)	Find the nearest enclosing parenthesized_expression that contains the given child node.	This PQL defect checks for number literal nodes that are enclosed by a parenthesized_expression and returns that enclosing node. defect defectGetEnclosing = when Cpp.NumberLiteral.is(&nl) and nl.toNode(&node) and Cpp.ParenthesizedExpression.getEnclosingParenthesizedExpression(node, &parent) and parent.nodeText(&txt) raise "Enclosing ParenthesizedExpression matched: \"{txt}\"" on parent In this C++ code the defect locates the parenthesized expression that encloses the inner number literals. void m() { int v = (1 + 2); }
isEnclosedInParenthesizedExpression(Cpp.Node.Node child)	Check whether the given child node has any parenthesized_expression ancestor.	This PQL defect checks whether a binary expression node is inside some parenthesized_expression. defect defectIsEnclosed = when Cpp.BiaryExpression.is(&be) and be.toNode(&node) and Cpp.ParenthesizedExpression.isEnclosedInParenthesizedExpression(node) and node.nodeText(&txt) raise "Node is enclosed in ParenthesizedExpression: \"{txt}\"" on node In this C++ code the defect verifies that the binary expression 1 + 2 is enclosed in parentheses. void n() { int r = (1 + 2); }

Version History

Introduced in R2026a