Cpp.RequiresExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the requires_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.RequiresExpression represents the node requires_expression in the syntax tree of your code.

template<typename T>
concept Addable = requires (T t) { t + t; };
int main() {}

The requires (T t) { t + t; } line is the requires_expression node that Cpp.RequiresExpression models.

Predicates

Type

Type	Raisable	Printable
RequiresExpression	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 RequiresExpression &re)	Matches a requires_expression node and binds it to re for further inspection or reporting.	This PQL defect checks for any requires_expression nodes in the syntax tree. defect findRequiresIs = when Cpp.RequiresExpression.is(&re) and re.nodeText(&txt) raise "requires found: \"{txt}\"" on re In this C++ code, the defect finds the requires expression used to define a concept. template<typename T> concept Addable = requires (T t) { t + t; }; int main() {}
cast(Cpp.Node.Node node, required RequiresExpression &cast)	Checks whether the given node is a requires_expression and if so binds it to cast for requiring-specific queries.	This PQL defect checks whether an arbitrary Node is actually a requires_expression node. defect findRequiresByNode = when Cpp.Node.is(&n, &,&,&) and Cpp.RequiresExpression.cast(n, &re) and re.nodeText(&txt) raise "node cast to requires: \"{txt}\"" on re In this C++ code, the defect tests a generic syntax node and confirms it is the requires expression in the concept declaration. template<typename T> concept Addable = requires (T t) { t + t; }; int main() {}
isa(Cpp.Node.Node node)	Returns true when node is a requires_expression allowing checks or negations against arbitrary Node values.	This PQL defect checks whether a given Node represents a requires_expression. defect checkIsa = when Cpp.Node.is(&n, &,&,&) and Cpp.RequiresExpression.isa(n) raise "Node is a requires_expression" on n In this C++ code, the defect identifies the requires expression node by testing a generic node value. template<typename T> concept Addable = requires (T t) { t + t; }; int main() {}
parameters(RequiresExpression self, Cpp.Node.Node &child)	Matches the parameter-list node of a requires_expression and binds it to child.	This PQL defect checks for the parameter list portion of a requires_expression such as (T t). defect requiresParameters = when Cpp.RequiresExpression.is(&re) and re.parameters(&params) and params.nodeText(&txt) raise "requires parameters: \"{txt}\"" on params In this C++ code, the defect extracts the (T t) parameter list from the requires expression. template<typename T> concept Addable = requires (T t) { t + t; }; int main() {}
requirements(RequiresExpression self, Cpp.Node.Node &child)	Matches the requirement-body node of a requires_expression and binds it to child.	This PQL defect checks for the block of requirements inside a requires_expression such as { t + t; }. defect requiresBody = when Cpp.RequiresExpression.is(&re) and re.requirements(&body) and body.nodeText(&txt) raise "requires body: \"{txt}\"" on body In this C++ code, the defect finds the { t + t; } requirements block inside the requires expression. template<typename T> concept Addable = requires (T t) { t + t; }; int main() {}
getEnclosingRequiresExpression(Cpp.Node.Node child, required RequiresExpression &parent)	Finds the nearest enclosing requires_expression ancestor of child and binds it to parent.	This PQL defect checks for the closest requires_expression that contains a given node such as an expression inside the requirements block. defect findEnclosingRequires = when Cpp.Identifier.is(&id) and Cpp.RequiresExpression.getEnclosingRequiresExpression(id, &re) and re.nodeText(&txt) raise "enclosing requires: \"{txt}\"" on re In this C++ code, the defect takes an identifier inside the requirements and finds the surrounding requires expression. template<typename T> concept Addable = requires (T t) { t + t; }; // identifier 't' is inside the requirements block int main() {}
isEnclosedInRequiresExpression(Cpp.Node.Node child)	True when child has any requires_expression ancestor letting you match nodes located inside a requires context.	This PQL defect checks whether a node is located anywhere inside a requires_expression. defect checkInsideRequires = when Cpp.Identifier.is(&id) and Cpp.RequiresExpression.isEnclosedInRequiresExpression(id) raise "identifier is inside a requires expression" on id In this C++ code, the defect detects that the identifier t appears inside the requires expression body. template<typename T> concept Addable = requires (T t) { t + t; }; int main() {}

Version History

Introduced in R2026a