Cpp.TemplateType Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the template_type nodes in the syntax tree of your code

Since R2026a

Description

The PQL class TemplateType represents the node template_type in the syntax tree of your code.

Predicates

Type

Type	Raisable	Printable
`TemplateType`	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(TemplateType &tt)`	The `is` predicate identifies if a syntax node is a C++ template type instance. For example: std::vector<int> v; In `tree-sitter`, the structure is: (template_type name: (type_identifier) @name arguments: (type_argument_list (type_identifier) @arg)) The `is` predicate confirms that the `template_type` node represents a template type, such as `std::vector<int>`. This enables queries targeting template type usages in the code.	This example demonstrates using the `TemplateType.is` predicate to match `C++` template type nodes (e.g., `std::vector<int>`). The `C++` snippet below contains two template types that will be matched by the rule: #include <vector> void f() { std::vector<int> v; } rule CheckTemplateTypeIs = { defectTemplateTypeIs } defect defectTemplateTypeIs = when Cpp.TemplateType.is(&tt) and tt.nodeText(&txt) raise "TemplateType.is matched: "{txt}"" on tt
`isa(Ast.Node.Node node, TemplateType &cast)`	The `is` predicate identifies if a syntax node is a C++ template type instance. For example: std::vector<int> v; In `tree-sitter`, the structure is: (template_type name: (type_identifier) @name arguments: (type_argument_list (type_identifier) @arg)) The `is` predicate confirms that the `template_type` node represents a template type, such as `std::vector<int>`. This enables queries targeting template type usages in the code.	This example demonstrates using the `TemplateType.is` predicate to match `C++` template type nodes (e.g., `std::vector<int>`). The `C++` snippet below contains two template types that will be matched by the rule: #include <vector> void f() { std::vector<int> v; } rule CheckTemplateTypeIs = { defectTemplateTypeIs } defect defectTemplateTypeIs = when Cpp.TemplateType.is(&tt) and tt.nodeText(&txt) raise "TemplateType.is matched: "{txt}"" on tt
`arguments(TemplateType self, Ast.Node.Node &child)`	The `arguments` predicate retrieves each template argument node within a `TemplateType` node. It represents the types or values specified inside the angle brackets of a template instantiation. Example C++ code: <std::vector<int> v;/> Equivalent tree-sitter node: (template_type name: (scoped_identifier (identifier) @name) arguments: (template_argument_list (type_identifier) @arg)) The `arguments` predicate applied to the `template_type` node matches the `<int>` part, extracting the `int` as a template argument.	This example demonstrates how to use the `TemplateType.arguments` predicate to retrieve each template argument node from a `TemplateType` (e.g. `std::map<int, float>`) in a `C++` file. The `C++` snippet below contains a template instantiation that will trigger the rule. /* C++ source (example.cpp) / #include <map> void foo() { std::map<int, float> m; // TemplateType with two arguments: int and float } / PQL rule */ rule CheckTemplateArguments = { defectTemplateArguments } defect defectTemplateArguments = when Cpp.TemplateType.is(&tt) // get each argument node of the template type and tt.arguments(&arg) // obtain textual representation of the argument for the message and arg.nodeText(&txt) raise "TemplateType.arguments matched: '{txt}'" on arg
`name(TemplateType self, Ast.Node.Node &child)`	The `name` predicate retrieves the identifier node representing the template type's main name, such as the template class or struct name, from a `template_type` syntax node. Example C++ code: #include <map> void foo() { std::map<int, float> m; } Equivalent tree-sitter node snippet: (template_type name: (identifier) @name arguments: (type_identifier) @arg1 (type_identifier) @arg2) The `name` predicate applied to the `template_type` node matches the `identifier` node corresponding to `std::map`, effectively extracting the template's base name from the full template instantiation.	This example demonstrates using `TemplateType.name` to get the name node of a template type (for example `std::vector<int>`). The C++ snippet below will trigger the rule because it contains a template type declaration: #include <vector> void foo() { std::vector<int> v; } rule CheckTemplateTypeName = { defectName } defect defectName = when Cpp.TemplateType.is(&tt) and tt.name(&nm) and nm.nodeText(&txt) raise "TemplateType.name matched: '{txt}'" on nm

is(TemplateType &tt)

The is predicate identifies if a syntax node is a C++ template type instance.

For example:

std::vector<int> v;

In tree-sitter, the structure is:

(template_type
  name: (type_identifier) @name
  arguments: (type_argument_list
                (type_identifier) @arg))

The is predicate confirms that the template_type node represents a template type, such as std::vector<int>. This enables queries targeting template type usages in the code.

This example demonstrates using the TemplateType.is predicate to match C++ template type nodes (e.g., std::vector<int>). The C++ snippet below contains two template types that will be matched by the rule:

#include <vector>
void f() {
    std::vector<int> v;
}

rule CheckTemplateTypeIs = { defectTemplateTypeIs }
defect defectTemplateTypeIs =
    when
        Cpp.TemplateType.is(&tt)
        and tt.nodeText(&txt)
    raise "TemplateType.is matched: "{txt}""
    on tt

isa(Ast.Node.Node node, TemplateType &cast)

The is predicate identifies if a syntax node is a C++ template type instance.

For example:

std::vector<int> v;

In tree-sitter, the structure is:

(template_type
  name: (type_identifier) @name
  arguments: (type_argument_list
                (type_identifier) @arg))

The is predicate confirms that the template_type node represents a template type, such as std::vector<int>. This enables queries targeting template type usages in the code.

#include <vector>
void f() {
    std::vector<int> v;
}

rule CheckTemplateTypeIs = { defectTemplateTypeIs }
defect defectTemplateTypeIs =
    when
        Cpp.TemplateType.is(&tt)
        and tt.nodeText(&txt)
    raise "TemplateType.is matched: "{txt}""
    on tt

arguments(TemplateType self, Ast.Node.Node &child)

The arguments predicate retrieves each template argument node within a TemplateType node. It represents the types or values specified inside the angle brackets of a template instantiation.

Example C++ code:

<std::vector<int> v;/>

Equivalent tree-sitter node:

(template_type
  name: (scoped_identifier (identifier) @name)
  arguments: (template_argument_list (type_identifier) @arg))

The arguments predicate applied to the template_type node matches the <int> part, extracting the int as a template argument.

This example demonstrates how to use the TemplateType.arguments predicate to retrieve each template argument node from a TemplateType (e.g. std::map<int, float>) in a C++ file. The C++ snippet below contains a template instantiation that will trigger the rule.

/* C++ source (example.cpp) */
#include <map>
void foo() {
    std::map<int, float> m; // TemplateType with two arguments: int and float
}

/* PQL rule */
rule CheckTemplateArguments = { defectTemplateArguments }
defect defectTemplateArguments =
    when
        Cpp.TemplateType.is(&tt)
        // get each argument node of the template type
        and tt.arguments(&arg)
        // obtain textual representation of the argument for the message
        and arg.nodeText(&txt)
    raise "TemplateType.arguments matched: '{txt}'"
    on arg

name(TemplateType self, Ast.Node.Node &child)

The name predicate retrieves the identifier node representing the template type's main name, such as the template class or struct name, from a template_type syntax node.

Example C++ code:

#include <map>
void foo() {
    std::map<int, float> m;
}

Equivalent tree-sitter node snippet:

(template_type
  name: (identifier) @name
  arguments: (type_identifier) @arg1
             (type_identifier) @arg2)

The name predicate applied to the template_type node matches the identifier node corresponding to std::map, effectively extracting the template's base name from the full template instantiation.

This example demonstrates using TemplateType.name to get the name node of a template type (for example std::vector<int>). The C++ snippet below will trigger the rule because it contains a template type declaration:

#include <vector>
void foo() {
    std::vector<int> v;
}

rule CheckTemplateTypeName = { defectName }
defect defectName =
    when
        Cpp.TemplateType.is(&tt)
        and tt.name(&nm)
        and nm.nodeText(&txt)
    raise "TemplateType.name matched: '{txt}'"
    on nm

Version History

Introduced in R2026a