Ast.TypeRequirement Class

Namespace: Ast
Superclasses: AstNodeProperties

Represents the type_requirement nodes in the syntax tree of your code

Since R2026a

Description

The PQL class TypeRequirement represents the node type_requirement in the syntax tree of your code.

Predicates

Type

Type	Raisable	Printable
`TypeRequirement`	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

Predicates	Description	Example
`is(TypeRequirement &req)`	The `is` predicate matches a `type_requirement` node in a C++20 `requires` expression. This includes `typename` requirements. Example C++ code with the corresponding tree-sitter node: template<typename T> concept C = requires { typename T::value_type; }; // Tree-sitter node: type_requirement The `is` predicate identifies the `type_requirement` node for `typename T::value_type;` within the `requires` expression. This allows queries to focus on this type constraint.	This example shows how to detect `TypeRequirement` nodes in a `C++` `requires-expression` (e.g. inside a `concept`). The `C++` snippet contains several type requirements like `typename T::value_type` which will be matched by the `TypeRequirement.is` predicate. rule CheckTypeRequirementIs = { defectTypeRequirementIs } defect defectTypeRequirementIs = when Cpp.TypeRequirement.is(&tr) and tr.nodeText(&txt) raise "TypeRequirement.is matched: "{txt}"" on tr // Example C++ that would trigger the rule: // template<typename T> // concept C1 = requires { typename T::value_type; };
`isa(Cpp.Node.Node node, TypeRequirement &cast)`	The `is` predicate matches a `type_requirement` node in a C++20 `requires` expression. This includes `typename` requirements. Example C++ code with the corresponding tree-sitter node: template<typename T> concept C = requires { typename T::value_type; }; // Tree-sitter node: type_requirement The `is` predicate identifies the `type_requirement` node for `typename T::value_type;` within the `requires` expression. This allows queries to focus on this type constraint.	This example shows how to detect `TypeRequirement` nodes in a `C++` `requires-expression` (e.g. inside a `concept`). The `C++` snippet contains several type requirements like `typename T::value_type` which will be matched by the `TypeRequirement.is` predicate. rule CheckTypeRequirementIs = { defectTypeRequirementIs } defect defectTypeRequirementIs = when Cpp.TypeRequirement.is(&tr) and tr.nodeText(&txt) raise "TypeRequirement.is matched: "{txt}"" on tr // Example C++ that would trigger the rule: // template<typename T> // concept C1 = requires { typename T::value_type; };
`qualifiedIdentifier(TypeRequirement self, Cpp.Node.Node &child)`	The `qualifiedIdentifier` predicate matches a child node of a `type_requirement` that represents a qualified identifier. This includes nested type names using scope resolution, such as `T::value_type`. Example C++ code: template<typename T> concept C = requires { typename T::value_type; }; The equivalent tree-sitter node in snake_case is `type_requirement`. The `qualifiedIdentifier` predicate matches the `T::value_type` child node. It identifies the qualified name used as a type requirement within the requires clause.	This example demonstrates using `TypeRequirement.qualifiedIdentifier` to detect a qualified-id inside a `requires-type` requirement such as `"typename T::value_type"`. The C++ snippet below will trigger the rule: template<typename T> concept C1 = requires { typename T::value_type; }; rule CheckQualifiedIdentifier = { defectQualifiedIdentifier } defect defectQualifiedIdentifier = when Cpp.TypeRequirement.qualifiedIdentifier(&qid) and qid.nodeText(&txt) raise "TypeRequirement.qualifiedIdentifier matched: "{txt}"" on qid
`typeIdentifier(TypeRequirement self, Cpp.Node.Node &child)`	The `typeIdentifier` predicate matches the child node that represents a simple type name in a type requirement expression. Example C++ code: template<typename T> concept C2 = requires { typename T; }; The equivalent tree-sitter node is `type_requirement`. In the `type_requirement` node for `typename T;`, the `typeIdentifier` predicate matches the `T` node representing the required type name.	This example demonstrates how to use the `TypeRequirement.typeIdentifier` predicate to find `TypeRequirement` nodes whose child is a type identifier (e.g., in a requires expression like `requires { typename T::value_type; }`). The C++ snippet below triggers the rule because `T::value_type` is a type identifier inside a type requirement. rule CheckTypeIdentifier = { defectTypeIdentifier } defect defectTypeIdentifier = when Cpp.TypeRequirement.typeIdentifier(&tid) and tid.nodeText(&txt) raise "TypeRequirement.typeIdentifier matched: "{txt}"" on tid // Example C++ that would trigger this rule: // template<typename T> // concept C1 = requires { typename T::value_type; };
`templateType(TypeRequirement self, Cpp.Node.Node &child)`	The `templateType` predicate identifies a template instantiation type within a type requirement. For example, it identifies `std::vector<T>` in a `requires` clause. Example C++ code: template<typename T> concept C = requires { typename std::vector<T>; }; The equivalent tree-sitter node is `type_requirement`. In the `type_requirement` node representing `typename std::vector<T>;`, the `templateType` predicate matches the template instantiation `std::vector<T>`.	This example demonstrates how to use the `TypeRequirement.templateType` predicate to match a template type appearing inside a `requires`-type requirement (e.g. `typename std::vector<T>`) in a `C++` concept. The `C++` snippet below will trigger the rule because the requirement contains the template type `std::vector<T>`. rule CheckTemplateType = { defectTemplateType } defect defectTemplateType = when Cpp.TypeRequirement.templateType(&tt) and tt.nodeText(&txt) raise "TypeRequirement.templateType matched: "{txt}"" on tt // Example C++ snippet that would trigger the rule: // template<typename T> // concept C = requires { typename std::vector<T>; }

is(TypeRequirement &req)

The is predicate matches a type_requirement node in a C++20 requires expression. This includes typename requirements.

Example C++ code with the corresponding tree-sitter node:

template<typename T>
concept C = requires { typename T::value_type; };
// Tree-sitter node: type_requirement

The is predicate identifies the type_requirement node for typename T::value_type; within the requires expression. This allows queries to focus on this type constraint.

This example shows how to detect TypeRequirement nodes in a C++ requires-expression (e.g. inside a concept). The C++ snippet contains several type requirements like typename T::value_type which will be matched by the TypeRequirement.is predicate.

rule CheckTypeRequirementIs = { defectTypeRequirementIs }
defect defectTypeRequirementIs =
    when
        Cpp.TypeRequirement.is(&tr)
        and tr.nodeText(&txt)
    raise "TypeRequirement.is matched: "{txt}""
    on tr

// Example C++ that would trigger the rule:
// template<typename T>
// concept C1 = requires { typename T::value_type; };

isa(Cpp.Node.Node node, TypeRequirement &cast)

The is predicate matches a type_requirement node in a C++20 requires expression. This includes typename requirements.

Example C++ code with the corresponding tree-sitter node:

template<typename T>
concept C = requires { typename T::value_type; };
// Tree-sitter node: type_requirement

The is predicate identifies the type_requirement node for typename T::value_type; within the requires expression. This allows queries to focus on this type constraint.

rule CheckTypeRequirementIs = { defectTypeRequirementIs }
defect defectTypeRequirementIs =
    when
        Cpp.TypeRequirement.is(&tr)
        and tr.nodeText(&txt)
    raise "TypeRequirement.is matched: "{txt}""
    on tr

// Example C++ that would trigger the rule:
// template<typename T>
// concept C1 = requires { typename T::value_type; };

qualifiedIdentifier(TypeRequirement self, Cpp.Node.Node &child)

The qualifiedIdentifier predicate matches a child node of a type_requirement that represents a qualified identifier. This includes nested type names using scope resolution, such as T::value_type.

Example C++ code:

template<typename T>
concept C = requires { typename T::value_type; };

The equivalent tree-sitter node in snake_case is type_requirement.

The qualifiedIdentifier predicate matches the T::value_type child node. It identifies the qualified name used as a type requirement within the requires clause.

This example demonstrates using TypeRequirement.qualifiedIdentifier to detect a qualified-id inside a requires-type requirement such as "typename T::value_type". The C++ snippet below will trigger the rule:

template<typename T>
concept C1 = requires { typename T::value_type; };

rule CheckQualifiedIdentifier = { defectQualifiedIdentifier }
defect defectQualifiedIdentifier =
    when
        Cpp.TypeRequirement.qualifiedIdentifier(&qid)
        and qid.nodeText(&txt)
    raise "TypeRequirement.qualifiedIdentifier matched: "{txt}""
    on qid

typeIdentifier(TypeRequirement self, Cpp.Node.Node &child)

The typeIdentifier predicate matches the child node that represents a simple type name in a type requirement expression.

Example C++ code:

template<typename T> concept C2 = requires { typename T; };

The equivalent tree-sitter node is type_requirement.

In the type_requirement node for typename T;, the typeIdentifier predicate matches the T node representing the required type name.

This example demonstrates how to use the TypeRequirement.typeIdentifier predicate to find TypeRequirement nodes whose child is a type identifier (e.g., in a requires expression like requires { typename T::value_type; }). The C++ snippet below triggers the rule because T::value_type is a type identifier inside a type requirement.

rule CheckTypeIdentifier = { defectTypeIdentifier }
defect defectTypeIdentifier =
    when
        Cpp.TypeRequirement.typeIdentifier(&tid)
        and tid.nodeText(&txt)
    raise "TypeRequirement.typeIdentifier matched: "{txt}""
    on tid

// Example C++ that would trigger this rule:
// template<typename T>
// concept C1 = requires { typename T::value_type; };

templateType(TypeRequirement self, Cpp.Node.Node &child)

The templateType predicate identifies a template instantiation type within a type requirement. For example, it identifies std::vector<T> in a requires clause.

Example C++ code:

template<typename T>
concept C = requires { typename std::vector<T>; };

The equivalent tree-sitter node is type_requirement.

In the type_requirement node representing typename std::vector<T>;, the templateType predicate matches the template instantiation std::vector<T>.

This example demonstrates how to use the TypeRequirement.templateType predicate to match a template type appearing inside a requires-type requirement (e.g. typename std::vector<T>) in a C++ concept. The C++ snippet below will trigger the rule because the requirement contains the template type std::vector<T>.

rule CheckTemplateType = { defectTemplateType }
defect defectTemplateType =
    when
        Cpp.TypeRequirement.templateType(&tt)
        and tt.nodeText(&txt)
    raise "TypeRequirement.templateType matched: "{txt}""
    on tt

// Example C++ snippet that would trigger the rule:
// template<typename T>
// concept C = requires { typename std::vector<T>; }

Version History

Introduced in R2026a