Ast.TemplateDeclaration Class

Namespace: Ast
Superclasses: AstNodeProperties

Represents the template_declaration nodes in the syntax tree of your code

Since R2026a

Description

TemplateDeclaration class represents the C++ syntax node template_declaration in your code and contains predicates to query properties and children of this node.

Predicates

expand all

Type

Type	Raisable	Printable
`TemplateDeclaration`	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(TemplateDeclaration &decl)`	The `is` predicate identifies nodes corresponding to C++ template declarations. Example C++ code: template <typename T> void foo(T); Equivalent tree-sitter node: template_declaration The `is` predicate matches the `template_declaration` node. This enables queries to recognize and analyze all template declarations in the code.	The `PQL` rule finds top-level template declaration. rule CheckTemplateIs = { defectTemplateIs } defect defectTemplateIs = when Cpp.TemplateDeclaration.is(&td) and td.nodeText(&txt) raise "Found template declaration: \"{txt}\"" on td
`isa(Cpp.Node.Node node)`	The `isa` predicate identifies nodes corresponding to C++ template declarations.	The `PQL` rule finds template declaration by starting from generic syntax nodes. rule CheckTemplateIs = { defectTemplateIs } defect defectTemplateIs = when Cpp.Node.is(&node,&,&,&) Cpp.TemplateDeclaration.isa(node) and node.nodeText(&txt) raise "Found template declaration: \"{txt}\"" on node
`cast(Cpp.Node.Node node, required TemplateDeclaration &cast)`	The `cast` predicate identifies syntax nodes corresponding to C++ template declarations and returns them as `TemplateDeclaration` object.	The `PQL` rule finds template declaration by casting from generic syntax nodes. rule CheckTemplateIs = { defectTemplateIs } defect defectTemplateIs = when Cpp.Node.is(&node,&,&,&) Cpp.TemplateDeclaration.cast(node, &TD) and TD.nodeText(&txt) raise "Found template declaration: \"{txt}\"" on node
`parameters(TemplateDeclaration self, Cpp.Node.Node &child)`	The `parameters` predicate retrieves the template parameter list node (the `<...>` part) from a `TemplateDeclaration` syntax node. Example C++ code: template <typename T> void foo(T); The `parameters` predicate matches the template parameter list `<typename T>` within the `template_declaration` node.	This rule finds the parameters of a template declaration. rule CheckParameters = { defectParameters } defect defectParameters = when Cpp.TemplateDeclaration.parameters(&params) and params.nodeText(&txt) raise "TemplateDeclaration.parameters matched: "{txt}"" on params
`parameters(TemplateDeclaration self, Cpp.Node.Node &child)`	The `friendDeclaration` predicate identifies friend declarations within a template declaration node in the C++ syntax tree. Example C++ code: template <typename T> friend class Bar; This predicate matches the `friend class Bar;` node inside the `template_declaration`. It allows static analysis tools to detect friend declarations declared as templates.	This rule finds any `friend` declaration inside a template declaration. template <typename T> friend class Bar; rule CheckFriendDeclaration = { defectFriendDeclaration } defect defectFriendDeclaration = when Cpp.TemplateDeclaration.is(&td) and td.friendDeclaration(&fd) and fd.nodeText(&txt) raise "TemplateDeclaration.friendDeclaration matched: "{txt}"" on fd
`functionDefinition(TemplateDeclaration self, Cpp.Node.Node &child)`	The `functionDefinition` predicate identifies a child node of a `TemplateDeclaration` that represents a function definition. This means it finds a function with its body defined within the template. Example C++ code: template <typename T> void foo(T) {} // function_definition node The `functionDefinition` predicate matches the `function_definition` child node inside the `template_declaration`. It captures the function `foo` defined with a body `{}` inside the template declaration.	This rule finds function definition child nodes of a template declaration. rule CheckTemplateFunctionDefinition = { defectTemplateFunctionDefinition } defect defectTemplateFunctionDefinition = when Cpp.TemplateDeclaration.is(&td) and td.functionDefinition(&fd) and fd.nodeText(&txt) raise "TemplateDeclaration.functionDefinition matched: "{txt}"" on fd
`requiresClause(TemplateDeclaration self, Cpp.Node.Node &child)`	The `requiresClause` predicate identifies the presence of a `requires` clause in a template declaration. It matches the constraint expression following the `requires` keyword. Example C++ code: template <typename T> requires C<T> void bar(T); The `requiresClause` predicate applied to the `template_declaration` node matches the `requires C<T>` part. This allows static analysis to detect and work with template constraints specified via requires clauses.	This rule finds the `requires` clause inside a template declaration. rule CheckRequiresClause = { defectRequiresClause } defect defectRequiresClause = when Cpp.TemplateDeclaration.is(&td) and td.requiresClause(&rc) and rc.nodeText(&txt) raise "TemplateDeclaration.requiresClause matched: '{txt}'" on rc
`aliasDeclaration(TemplateDeclaration self, Cpp.Node.Node &child)`	The `aliasDeclaration` predicate identifies an alias declaration within a template declaration. This includes a `using` alias template. Example C++ code: template <typename T> using Ptr = T; The `aliasDeclaration` predicate matches the `using Ptr = T;` alias declaration inside the `template_declaration` node. This enables queries targeting template alias declarations.	This rule finds a `template alias` declaration (`using-declaration`) inside a `C++` template. rule CheckAliasDeclaration = { defectAliasDeclaration } defect defectAliasDeclaration = when Cpp.TemplateDeclaration.is(&td) and td.aliasDeclaration(&ad) and ad.nodeText(&txt) raise "TemplateDeclaration.aliasDeclaration matched: "{txt}"" on ad
`templateDeclaration(TemplateDeclaration self, Cpp.Node.Node &child)`	The `templateDeclaration` predicate identifies nested template declarations within a `TemplateDeclaration` node. It detects templates declared inside other templates. Example C++ code: template <typename T> template <typename U> struct S2 {}; The `templateDeclaration` predicate matches the inner `template <typename U>` declaration nested inside the outer `template <typename T>` declaration. This allows static analysis to recognize and process nested template declarations separately.	This rule finds nested template declarations. rule CheckTemplateDeclaration = { defectTemplateDeclaration } defect defectTemplateDeclaration = when Cpp.TemplateDeclaration.is(&td) and td.templateDeclaration(&nestedTd) and nestedTd.nodeText(&txt) raise "Found nested template declaration: '{txt}'" on nestedTd
`conceptDefinition(TemplateDeclaration self, Cpp.Node.Node &child)`	The `conceptDefinition` predicate identifies a child node in a template declaration that defines a C++20 concept. Example C++ code: template <typename T> concept C = requires(T t) { t + t; }; The `conceptDefinition` predicate matches the `concept C = requires(T t) { t + t; };` part inside the `template_declaration` node.	This rule detects template declarations that introduce a concept. rule CheckConceptDefinition = { defectConceptDefinition } defect defectConceptDefinition = when Cpp.TemplateDeclaration.is(&td) and td.conceptDefinition(&cd) and cd.nodeText(&txt) raise "Found template concept definition: "{txt}"" on cd
`typeSpecifier(TemplateDeclaration self, Cpp.Node.Node &child)`	The `typeSpecifier` predicate identifies the type specifier node, such as class, struct, or enum name, within a template declaration. Example C++ code: template <typename T> struct S; The `typeSpecifier` predicate matches the `struct S` part inside the `template_declaration`. This allows queries to focus on the type being declared by the template.	This example finds template declarations whose parameter list includes a type specifier. rule CheckTemplateTypeSpecifier = { defectTemplateTypeSpecifier } defect defectTemplateTypeSpecifier = when Cpp.TemplateDeclaration.is(&td) and td.typeSpecifier(&ts) and ts.nodeText(&txt) raise "TemplateDeclaration.typeSpecifier matched: '{txt}'" on ts
`declaration(TemplateDeclaration self, Cpp.Node.Node &child)`	The `declaration` predicate identifies the declaration node within a template declaration.	This rule finds the declaration nodes within a template declaration. rule CheckTemplateDeclarationChild = { defectTemplateDeclarationChild } defect defectTemplateDeclarationChild = when Cpp.TemplateDeclaration.is(&td) and td.declaration(&decl) // &decl is the output child node bound by the predicate and decl.nodeText(&txt) raise "TemplateDeclaration.declaration matched: "{txt}"" on decl

is(TemplateDeclaration &decl)

The is predicate identifies nodes corresponding to C++ template declarations.

Example C++ code:

template <typename T> void foo(T);

Equivalent tree-sitter node:

template_declaration

The is predicate matches the template_declaration node. This enables queries to recognize and analyze all template declarations in the code.

The PQL rule finds top-level template declaration.

rule CheckTemplateIs = { defectTemplateIs }
defect defectTemplateIs =
    when
        Cpp.TemplateDeclaration.is(&td)
        and td.nodeText(&txt)
    raise "Found template declaration: \"{txt}\""
    on td

isa(Cpp.Node.Node node)

The isa predicate identifies nodes corresponding to C++ template declarations.

The PQL rule finds template declaration by starting from generic syntax nodes.

rule CheckTemplateIs = { defectTemplateIs }
defect defectTemplateIs =
    when
        Cpp.Node.is(&node,&,&,&)
        Cpp.TemplateDeclaration.isa(node)
        and node.nodeText(&txt)
    raise "Found template declaration: \"{txt}\""
    on node

cast(Cpp.Node.Node node, required TemplateDeclaration &cast)

The cast predicate identifies syntax nodes corresponding to C++ template declarations and returns them as TemplateDeclaration object.

The PQL rule finds template declaration by casting from generic syntax nodes.

rule CheckTemplateIs = { defectTemplateIs }
defect defectTemplateIs =
    when
        Cpp.Node.is(&node,&,&,&)
        Cpp.TemplateDeclaration.cast(node, &TD)
        and TD.nodeText(&txt)
    raise "Found template declaration: \"{txt}\""
    on node

parameters(TemplateDeclaration self, Cpp.Node.Node &child)

The parameters predicate retrieves the template parameter list node (the <...> part) from a TemplateDeclaration syntax node.

Example C++ code:

template <typename T>
void foo(T);

The parameters predicate matches the template parameter list <typename T> within the template_declaration node.

This rule finds the parameters of a template declaration.

rule CheckParameters = { defectParameters }
defect defectParameters =
    when
        Cpp.TemplateDeclaration.parameters(&params)
        and params.nodeText(&txt)
    raise "TemplateDeclaration.parameters matched: "{txt}""
    on params

parameters(TemplateDeclaration self, Cpp.Node.Node &child)

The friendDeclaration predicate identifies friend declarations within a template declaration node in the C++ syntax tree.

Example C++ code:

template <typename T> friend class Bar;

This predicate matches the friend class Bar; node inside the template_declaration. It allows static analysis tools to detect friend declarations declared as templates.

This rule finds any friend declaration inside a template declaration.

template <typename T>
friend class Bar;

rule CheckFriendDeclaration = { defectFriendDeclaration }
defect defectFriendDeclaration =
    when
        Cpp.TemplateDeclaration.is(&td)
        and td.friendDeclaration(&fd)
        and fd.nodeText(&txt)
    raise "TemplateDeclaration.friendDeclaration matched: "{txt}""
    on fd

functionDefinition(TemplateDeclaration self, Cpp.Node.Node
                  &child)

The functionDefinition predicate identifies a child node of a TemplateDeclaration that represents a function definition. This means it finds a function with its body defined within the template.

Example C++ code:

template <typename T>
void foo(T) {}  // function_definition node

The functionDefinition predicate matches the function_definition child node inside the template_declaration. It captures the function foo defined with a body {} inside the template declaration.

This rule finds function definition child nodes of a template declaration.

rule CheckTemplateFunctionDefinition = { defectTemplateFunctionDefinition }
defect defectTemplateFunctionDefinition =
    when
        Cpp.TemplateDeclaration.is(&td)
        and td.functionDefinition(&fd)
        and fd.nodeText(&txt)
    raise "TemplateDeclaration.functionDefinition matched: "{txt}""
    on fd

requiresClause(TemplateDeclaration self, Cpp.Node.Node
                  &child)

The requiresClause predicate identifies the presence of a requires clause in a template declaration. It matches the constraint expression following the requires keyword.

Example C++ code:

template <typename T>
requires C<T>
void bar(T);

The requiresClause predicate applied to the template_declaration node matches the requires C<T> part. This allows static analysis to detect and work with template constraints specified via requires clauses.

This rule finds the requires clause inside a template declaration.

rule CheckRequiresClause = { defectRequiresClause }
defect defectRequiresClause =
    when
        Cpp.TemplateDeclaration.is(&td)
        and td.requiresClause(&rc)
        and rc.nodeText(&txt)
    raise "TemplateDeclaration.requiresClause matched: '{txt}'"
    on rc

aliasDeclaration(TemplateDeclaration self, Cpp.Node.Node
                  &child)

The aliasDeclaration predicate identifies an alias declaration within a template declaration. This includes a using alias template.

Example C++ code:

template <typename T> using Ptr = T*;

The aliasDeclaration predicate matches the using Ptr = T*; alias declaration inside the template_declaration node. This enables queries targeting template alias declarations.

This rule finds a template alias declaration (using-declaration) inside a C++ template.

rule CheckAliasDeclaration = { defectAliasDeclaration }
defect defectAliasDeclaration =
    when
        Cpp.TemplateDeclaration.is(&td)
        and td.aliasDeclaration(&ad)
        and ad.nodeText(&txt)
    raise "TemplateDeclaration.aliasDeclaration matched: "{txt}""
    on ad

templateDeclaration(TemplateDeclaration self, Cpp.Node.Node
                  &child)

The templateDeclaration predicate identifies nested template declarations within a TemplateDeclaration node. It detects templates declared inside other templates.

Example C++ code:

template <typename T>
template <typename U>
struct S2 {};

The templateDeclaration predicate matches the inner template <typename U> declaration nested inside the outer template <typename T> declaration. This allows static analysis to recognize and process nested template declarations separately.

This rule finds nested template declarations.

rule CheckTemplateDeclaration = { defectTemplateDeclaration }
defect defectTemplateDeclaration =
    when
        Cpp.TemplateDeclaration.is(&td)
        and td.templateDeclaration(&nestedTd)
        and nestedTd.nodeText(&txt)
    raise "Found nested template declaration: '{txt}'"
    on nestedTd

conceptDefinition(TemplateDeclaration self, Cpp.Node.Node
                  &child)

The conceptDefinition predicate identifies a child node in a template declaration that defines a C++20 concept.

Example C++ code:

template <typename T>
concept C = requires(T t) { t + t; };

The conceptDefinition predicate matches the concept C = requires(T t) { t + t; }; part inside the template_declaration node.

This rule detects template declarations that introduce a concept.

rule CheckConceptDefinition = { defectConceptDefinition }
defect defectConceptDefinition =
    when
        Cpp.TemplateDeclaration.is(&td)
        and td.conceptDefinition(&cd)
        and cd.nodeText(&txt)
    raise "Found template concept definition: "{txt}""
    on cd

typeSpecifier(TemplateDeclaration self, Cpp.Node.Node &child)

The typeSpecifier predicate identifies the type specifier node, such as class, struct, or enum name, within a template declaration.

Example C++ code:

template <typename T>
struct S;

The typeSpecifier predicate matches the struct S part inside the template_declaration. This allows queries to focus on the type being declared by the template.

This example finds template declarations whose parameter list includes a type specifier.

rule CheckTemplateTypeSpecifier = { defectTemplateTypeSpecifier }
defect defectTemplateTypeSpecifier =
    when
        Cpp.TemplateDeclaration.is(&td)
        and td.typeSpecifier(&ts)            
        and ts.nodeText(&txt)
    raise "TemplateDeclaration.typeSpecifier matched: '{txt}'"
    on ts

declaration(TemplateDeclaration self, Cpp.Node.Node &child)

The declaration predicate identifies the declaration node within a template declaration.

This rule finds the declaration nodes within a template declaration.

rule CheckTemplateDeclarationChild = { defectTemplateDeclarationChild }
defect defectTemplateDeclarationChild =
    when
        Cpp.TemplateDeclaration.is(&td)
        and td.declaration(&decl)                      // &decl is the output child node bound by the predicate
        and decl.nodeText(&txt)
    raise "TemplateDeclaration.declaration matched: "{txt}""
    on decl

Version History

Introduced in R2026a