Cpp.ConditionalExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the conditional_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class ConditionalExpression represents the node conditional_expression in the syntax tree of your code.

// example.cpp
int f(int a, int b, int c, bool flag) {
  int x = a ? b : c;
  int y = (flag ? 1 : 0) + 2;
  return x + y;
}

The code contains two conditional_expression nodes: a ? b : c and flag ? 1 : 0, which correspond to the PQL ConditionalExpression node.

Predicates

Type

Type	Raisable	Printable
ConditionalExpression	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 ConditionalExpression &ce)	Matches a conditional_expression node and returns it as ce. Wse this to directly obtain the conditional-expression node.	This PQL defect checks for any conditional_expression node in the translation unit. defect find_conditional = when Cpp.ConditionalExpression.is(&ce) and ce.nodeText(&txt) raise "Found conditional: \"{txt}\"" on ce In this C++ code, the defect finds each ternary expression such as a ? b : c. // main.cpp int main() { int a=1,b=2,c=3; int v = a ? b : c; return v; }
cast(Cpp.Node.Node node, required ConditionalExpression &cast)	Checks whether a generic Cpp.Node.Node is a conditional_expression. If so, returns it as cast.	This PQL defect checks nodes already obtained as generic Cpp.Node.Node and narrows them to conditional_expression. defect cast_to_conditional = when Cpp.Node.is(&node, &,&,&) and Cpp.ConditionalExpression.cast(node, &ce) and ce.nodeText(&txt) raise "Casted to conditional: \"{txt}\"" on ce In this C++ code, the defect finds the node representing flag ? 1 : 0. // main.cpp bool flag=false; int main() { int r = flag ? 1 : 0; return r; }
isa(Cpp.Node.Node node)	Returns true if the given Cpp.Node.Node is a conditional_expression. Use this predicate for boolean checks or negation.	This PQL defect checks whether a node is a conditional_expression using a boolean predicate. defect node_is_conditional = when Cpp.Node.is(&node, &,&,&) and Cpp.ConditionalExpression.isa(node) raise "Node is a conditional expression" on node In this C++ code, the defect identifies that a ? b : c corresponds to a conditional_expression node. // main.cpp int a=1,b=2,c=3; int main() { int t = a ? b : c; return t; }
condition(ConditionalExpression self, Cpp.Node.Node &child)	Extracts the condition node from a conditional_expression.	This PQL defect checks for the condition node of a conditional_expression. defect conditional_condition = when Cpp.ConditionalExpression.is(&ce) and ce.condition(&cond) and cond.nodeText(&txt) raise "Condition is \"{txt}\"" on cond In this C++ code, the defect inspects the condition part flag of flag ? 1 : 0. // main.cpp bool flag=true; int main() { int v = flag ? 100 : -1; return v; }
consequence(ConditionalExpression self, Cpp.Node.Node &child)	Extracts the consequence node from a conditional_expression.	This PQL defect checks for the consequence node of a conditional_expression. defect conditional_consequence = when Cpp.ConditionalExpression.is(&ce) and ce.consequence(&cons) and cons.nodeText(&txt) raise "Consequence is \"{txt}\"" on cons In this C++ code, the defect finds the true-branch value 1 in flag ? 1 : 0. // main.cpp bool flag=false; int main() { int v = flag ? 1 : 0; return v; }
alternative(ConditionalExpression self, Cpp.Node.Node &child)	Extracts the alternative node from a conditional_expression.	This PQL defect checks for the alternative subnode of a conditional_expression. defect conditional_alternative = when Cpp.ConditionalExpression.is(&ce) and ce.alternative(&alt) and alt.nodeText(&txt) raise "Alternative is \"{txt}\"" on alt In this C++ code, the defect inspects the false-branch c of a ? b : c. // main.cpp int a=1,b=2,c=5; int main() { int v = a ? b : c; return v; }
getEnclosingConditionalExpression(Cpp.Node.Node child, required ConditionalExpression &parent)	Finds the nearest enclosing conditional_expression that contains the given child node and returns it as parent.	This PQL defect checks which conditional_expression directly contains a given child node. defect find_enclosing_conditional = when Cpp.Node.is(&node, &,&,&) and Cpp.ConditionalExpression.getEnclosingConditionalExpression(node, &parent) and parent.nodeText(&txt) raise "Enclosing conditional: \"{txt}\"" on parent In this C++ code, the defect finds a parent conditional expression that contains a generic syntax node. // main.cpp bool flag=false; int main() { int v = (flag ? 1 : 0) + 3; return v; }
isEnclosedInConditionalExpression(Cpp.Node.Node child)	Returns true if the given child node has a conditional_expression ancestor.	This PQL defect checks whether a number_literal node lies inside a conditional_expression. defect child_in_conditional = when Cpp.Node.is(&node, &,&,&) and Cpp.NumberLiteral.isa(node) and Cpp.ConditionalExpression.isEnclosedInConditionalExpression(node) raise "Node is enclosed in a conditional expression" on node In this C++ code, the defect detects number literals that are within a conditional expression. // main.cpp bool flag=true; int main() { int v = flag ? 1 : 0; //mactches (void)0; // does not match return v; }

Version History

Introduced in R2026a