Cpp.RequiresClause Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the requires_clause nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.RequiresClause represents the node requires_clause in the syntax tree of your code.

template<typename T>
requires std::integral<T>
void foo(T t) {}

The requires std::integral<T> part of the example corresponds to the requires_clause node handled by Cpp.RequiresClause.

Predicates

Type

Type	Raisable	Printable
RequiresClause	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 RequiresClause &rc)	Checks whether a syntax node is a requires_clause and binds it to rc. Use this to directly select requires clauses.	This PQL defect checks for requires_clause nodes directly. defect defectIs = when Cpp.RequiresClause.is(&rc) and rc.nodeText(&txt) raise "RequiresClause.is matched: \"{txt}\"" on rc In this C++ code the defect finds the requires clauses on declarations. template<typename T> requires (sizeof(T) <= 8 && sizeof(T) >= 1) void foo(T) {} int main() { foo(42); // OK - int satisfies the requirements foo('a'); // OK - char satisfies the requirements return 0; }
cast(Cpp.Node.Node node, required RequiresClause &cast)	Treats an arbitrary Node as a requires_clause if its runtime kind matches and binds it to cast. Use this when you have a generic node and need requires_clause-specific predicates.	This PQL defect checks for requires_clause nodes by converting from a generic Node. defect defectCast = when Cpp.TemplateDeclaration.is(&td) and td.getADescendant(&node) and Cpp.RequiresClause.cast(node, &rc) and rc.nodeText(&txt) raise "RequiresClause.cast matched: \"{txt}\"" on rc In this C++ code the defect finds a requires clause attached to a template definition by first selecting the template definition node. template<typename T> requires (sizeof(T) <= 8 && sizeof(T) >= 1) void foo(T) {} int main() { foo(42); // OK - int satisfies the requirements foo('a'); // OK - char satisfies the requirements return 0; }
isa(Cpp.Node.Node node)	Checks whether a generic Node is a requires_clause without binding it. Use this for boolean tests or negations.	This PQL defect checks whether a generic Node is a requires_clause. defect defectIsa = when Cpp.TemplateDeclaration.is(&td) and td.getADescendant(&node) and Cpp.RequiresClause.isa(node) raise "Node is a RequiresClause" on td In this C++ code the defect verifies that a template declaration contains a requires clause node when converted to a generic node. template<typename T> requires (sizeof(T) <= 8 && sizeof(T) >= 1) void foo(T) {} int main() { foo(42); // OK - int satisfies the requirements foo('a'); // OK - char satisfies the requirements return 0; }
constraint(RequiresClause self, Cpp.Node.Node &child)	Selects the constraint expression node inside a requires_clause and binds it to child. Use this to inspect the concept or expression following requires.	This PQL defect checks for the constraint expression inside a requires_clause. defect defectConstraint = when Cpp.RequiresClause.is(&rc) and rc.constraint(&constraint) and constraint.nodeText(&txt) raise "RequiresClause.constraint matched: \"{txt}\"" on constraint In this C++ code the defect extracts the std::integral<T> constraint inside the requires clause. #include <concepts> template<typename T> requires std::integral<T> void foo(T) {} int main() {}
getEnclosingRequiresClause(Cpp.Node.Node child, required RequiresClause &parent)	Finds the nearest enclosing requires_clause that contains child and binds it to parent. Use this to map inner nodes back to their requires context.	This PQL defect checks for the nearest enclosing requires_clause of a given inner node. defect defectEnclosing = when Cpp.TypeIdentifier.is(&id) and id.toNode(&node) and Cpp.RequiresClause.getEnclosingRequiresClause(node, &rc) raise "Identifier is inside requires clause" on id In this C++ code the defect finds type identifiers that appear inside a requires constraint. #include <concepts> template<typename T> requires std::integral<T> void foo(T) {} int main() {}
isEnclosedInRequiresClause(Cpp.Node.Node child)	Checks whether child has any requires_clause ancestor. Use this to filter nodes that appear within requires clauses.	This PQL defect checks whether a given type identifier is anywhere inside a requires_clause. defect defectIsEnclosed = when Cpp.TypeIdentifier.is(&id) and id.toNode(&node) and Cpp.RequiresClause.isEnclosedInRequiresClause(node) raise "Identifier enclosed in requires clause" on id In this C++ code the defect flags type identifiers that belong to the requires constraint expression. #include <concepts> template<typename T> requires std::integral<T> void foo(T) {} int main() {}

Version History

Introduced in R2026a