Cpp.TemplateType Class

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

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

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

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