Ast.TypeRequirement Class

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; };

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; };

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

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; };

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>; }