Cpp.GenericExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the generic_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.GenericExpression represents the node generic_expression in the syntax tree of your code.

// c11 example using _Generic expression
#include <stdio.h>

int main(void) {
    int x = 3;
    int y = _Generic(x, int: 1, float: 2);
    (void)y;
    return 0;
}

The _Generic(x, int: 1, float: 2) expression in the code corresponds to the generic_expression node and is represented by Cpp.GenericExpression in PQL.

Predicates

Type

Type	Raisable	Printable
GenericExpression	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 GenericExpression &ge)	Checks whether a syntax node is a generic_expression and binds it to ge for further queries.	This PQL defect checks for generic_expression nodes in the code. defect FindGenericIs = when Cpp.GenericExpression.is(&ge) and ge.nodeText(&txt) raise "Found generic expression: \"{txt}\"" on ge In this C++ code the defect finds occurrences of the C11 _Generic expression. int main(void) { int a = 0; int b = _Generic(a, int: 10, default: 0); (void)b; return 0; }
cast(Cpp.Node.Node node, required GenericExpression &cast)	If node is a generic_expression this binds that generic_expression to cast so you can query its properties.	This PQL defect checks for generic_expression nodes in a return statement by starting with the descendant nodes of a return statement ad then casting to generic expression. defect FindGenericCast = when Cpp.ReturnStatement.is(&ret) and ret.getADescendant(&node) and Cpp.GenericExpression.cast(node, &cast) and cast.nodeText(&txt) raise "Cast to GenericExpression matched: \"{txt}\"" on cast In this C++ code the defect finds the generic expression in the return statement. int foo(int x) { return _Generic(x, int: 1, float: 2); }
isa(Cpp.Node.Node node)	Checks whether the general Node is specifically a generic_expression and returns true or false.	This PQL defect checks whether the value of a declarator is a generic_expression. defect FindGenericIsa = when Cpp.Declaration.is(&dec) and dec.getADescendant(&value) and Cpp.GenericExpression.isa(value) and value.nodeText(&txt) raise "isa confirms generic_expression: \"{txt}\"" on value In this C++ code the defect finds generic expressions on the right side of a declaration statement. #include <stdio.h> int main(void) { int v = 1; int r = _Generic(v, int: 9, default: 0); (void)r; return 0; }
typeDescriptor(GenericExpression self, Cpp.Node.Node &child)	Selects the type_descriptor child of a generic_expression and binds it to child.	This PQL defect checks for type_descriptor children inside a generic_expression. defect FindTypeDescriptor = when Cpp.GenericExpression.is(&ge) and ge.typeDescriptor(&td) and td.nodeText(&txt) raise "GenericExpression.typeDescriptor: \"{txt}\"" on ge In this C++ code the defect extracts the type label part such as int: inside the _Generic expression. int main(void) { int v = 2; int x = _Generic(v, int: 1, float: 2); (void)x; return 0; }
expression(GenericExpression self, Cpp.Node.Node &child)	Selects the expression child of a generic_expression and binds it to child.	This PQL defect checks for the expression child inside a generic_expression, such as the controlling expression or an associated result expression. defect FindGenericExpressionChild = when Cpp.GenericExpression.is(&ge) and ge.expression(&ex) and ex.nodeText(&txt) raise "GenericExpression.expression: \"{txt}\"" on ge In this C++ code the defect identifies the controlling expression v or the result expressions like 1 or 2 within _Generic. int main(void) { int v = 5; int y = _Generic(v, int: 1, float: 2); (void)y; return 0; }
getEnclosingGenericExpression(Cpp.Node.Node child, required GenericExpression &parent)	Finds the nearest ancestor generic_expression that encloses the child node and binds it to parent.	This PQL defect checks for an identifier and then finds its closest parent generic expression. defect EnclosingGeneric = when Cpp.Identifier.is(&id) and id.toNode(&n) and Cpp.GenericExpression.getEnclosingGenericExpression(n, &parent) and parent.nodeText(&txt) raise "Enclosing generic expression: \"{txt}\"" on parent In this C++ code the defect finds the _Generic expression that encloses an identifier used inside it. int main(void) { int v = 0; int r = _Generic(v, int: 1, float: 2); // identifier 'v' is enclosed in the generic expression (void)r; return 0; }
isEnclosedInGenericExpression(Cpp.Node.Node child)	Matches if child has any ancestor that is a generic_expression.	This PQL defect checks whether a lnumber literal node occurs anywhere inside a generic_expression. defect EnclosedInGeneric = when Cpp.Literal.is(&lit) and lit.toNode(&n) and Cpp.GenericExpression.isEnclosedInGenericExpression(n) and n.nodeText(&txt) raise "Literal enclosed in generic_expression: \"{txt}\"" on n In this C++ code the defect detects number literal result expressions such as 1 or 2 that appear inside the _Generic. int main(void) { int v = 0; int r = _Generic(v, int: 1, float: 2); // the literal 1 is enclosed in the generic expression (void)r; return 0; }

Version History

Introduced in R2026a