Ast.UsingDeclaration Class

Namespace: Ast
Superclasses: AstNodeProperties

Represents the using_declaration nodes in the syntax tree of your code

Since R2026a

Description

The PQL class UsingDeclaration represents the node using_declaration in the syntax tree of your code.

Using Declaration u = someNamespace::using_declaration;

In this code, the using_declaration node corresponds to a using declaration in C++ such as using namespace std; or using std::printf; in the source.

Predicates

expand all

Type

Type	Raisable	Printable
`UsingDeclaration`	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(UsingDeclaration &decl)`	The predicate `is` identifies nodes that represent a C++ using declaration. This includes type aliases and qualified names. Example C++ code: #include <vector> using std::vector; // using_declaration node using MyType = int; // using_declaration node The equivalent tree-sitter node is `using_declaration`. The predicate `UsingDeclaration.is` matches these nodes. This allows queries to recognize and analyze such constructs in the syntax tree.	This example shows a `PQL` rule that matches `C++` using-declarations (e.g. `'using std::vector;'`) by using the `UsingDeclaration.is` predicate. The `C++` snippet below will trigger the rule: #include <vector> using std::vector; void foo() { vector<int> v; } rule CheckUsingDeclarationIs = { defectUsingIs } defect defectUsingIs = when Cpp.UsingDeclaration.is(&ud) and ud.nodeText(&txt) raise "UsingDeclaration.is matched: '{txt}'" on ud
`isa(Cpp.Node.Node node, UsingDeclaration &cast)`	The predicate `is` identifies nodes that represent a C++ using declaration. This includes type aliases and qualified names. Example C++ code: #include <vector> using std::vector; // using_declaration node using MyType = int; // using_declaration node The equivalent tree-sitter node is `using_declaration`. The predicate `UsingDeclaration.is` matches these nodes. This allows queries to recognize and analyze such constructs in the syntax tree.	This example shows a `PQL` rule that matches `C++` using-declarations (e.g. `'using std::vector;'`) by using the `UsingDeclaration.is` predicate. The `C++` snippet below will trigger the rule: #include <vector> using std::vector; void foo() { vector<int> v; } rule CheckUsingDeclarationIs = { defectUsingIs } defect defectUsingIs = when Cpp.UsingDeclaration.is(&ud) and ud.nodeText(&txt) raise "UsingDeclaration.is matched: '{txt}'" on ud
`identifier(UsingDeclaration self, Cpp.Node.Node &child)`	The `identifier` predicate retrieves the simple identifier node for the name introduced or referenced by a `using` declaration. For example, consider the following C++ code: // C++ code: using MyType = int; // Equivalent tree-sitter node: // (using_declaration // name: (identifier) @id // ...) The `identifier` predicate matches the `MyType` identifier node within the `using_declaration`. This predicate locates the identifier token that names the alias or entity declared by the `using` statement.	This example demonstrates using `UsingDeclaration.identifier` to find the simple identifier introduced by a C++ using-declaration. The C++ snippet below will trigger the rule because `using std::vector;` contains the identifier `vector`. #include <vector> using std::vector; void foo() { vector<int> v; } rule CheckUsingIdentifier = { defectUsingIdentifier } defect defectUsingIdentifier = when Cpp.UsingDeclaration.is(&ud) and ud.identifier(&id) and id.nodeText(&txt) raise "UsingDeclaration.identifier matched: '{txt}'" on ud
`qualifiedIdentifier(UsingDeclaration self, Cpp.Node.Node &child)`	The predicate `qualifiedIdentifier` retrieves the fully qualified identifier in a C++ `using` declaration. Example C++ code: using std::vector; Equivalent tree-sitter node: (using_declaration (qualified_identifier (namespace_identifier) (identifier))) The `qualifiedIdentifier` predicate matches the qualified name `std::vector` in the using declaration. This allows static analysis to identify the exact symbol being imported.	This example demonstrates using `UsingDeclaration.qualifiedIdentifier` to match a using declaration that refers to a qualified name (e.g. `"std::vector"`). The C++ snippet below would trigger the rule because it contains a using declaration that names a qualified identifier. #include <vector> using std::vector; void foo() { vector<int> v; } rule CheckQualifiedIdentifier = { defectQualifiedIdentifier } defect defectQualifiedIdentifier = when Cpp.UsingDeclaration.is(&ud) and ud.qualifiedIdentifier(&qid) and qid.nodeText(&txt) raise "UsingDeclaration.qualifiedIdentifier matched: "{txt}"" on ud

is(UsingDeclaration &decl)

The predicate is identifies nodes that represent a C++ using declaration. This includes type aliases and qualified names.

Example C++ code:

#include <vector>
using std::vector;    // using_declaration node
using MyType = int;   // using_declaration node

The equivalent tree-sitter node is using_declaration. The predicate UsingDeclaration.is matches these nodes. This allows queries to recognize and analyze such constructs in the syntax tree.

This example shows a PQL rule that matches C++ using-declarations (e.g. 'using std::vector;') by using the UsingDeclaration.is predicate. The C++ snippet below will trigger the rule:

#include <vector>
using std::vector;

void foo() {
    vector<int> v;
}

rule CheckUsingDeclarationIs = { defectUsingIs }
defect defectUsingIs =
    when
        Cpp.UsingDeclaration.is(&ud)
        and ud.nodeText(&txt)
    raise "UsingDeclaration.is matched: '{txt}'"
    on ud

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

The predicate is identifies nodes that represent a C++ using declaration. This includes type aliases and qualified names.

Example C++ code:

#include <vector>
using std::vector;    // using_declaration node
using MyType = int;   // using_declaration node

The equivalent tree-sitter node is using_declaration. The predicate UsingDeclaration.is matches these nodes. This allows queries to recognize and analyze such constructs in the syntax tree.

This example shows a PQL rule that matches C++ using-declarations (e.g. 'using std::vector;') by using the UsingDeclaration.is predicate. The C++ snippet below will trigger the rule:

#include <vector>
using std::vector;

void foo() {
    vector<int> v;
}

rule CheckUsingDeclarationIs = { defectUsingIs }
defect defectUsingIs =
    when
        Cpp.UsingDeclaration.is(&ud)
        and ud.nodeText(&txt)
    raise "UsingDeclaration.is matched: '{txt}'"
    on ud

identifier(UsingDeclaration self, Cpp.Node.Node &child)

The identifier predicate retrieves the simple identifier node for the name introduced or referenced by a using declaration.

For example, consider the following C++ code:

// C++ code:
using MyType = int;

// Equivalent tree-sitter node:
// (using_declaration
//   name: (identifier) @id
//   ...)

The identifier predicate matches the MyType identifier node within the using_declaration. This predicate locates the identifier token that names the alias or entity declared by the using statement.

This example demonstrates using UsingDeclaration.identifier to find the simple identifier introduced by a C++ using-declaration. The C++ snippet below will trigger the rule because using std::vector; contains the identifier vector.

#include <vector>
using std::vector;

void foo() { vector<int> v; }

rule CheckUsingIdentifier = { defectUsingIdentifier }
defect defectUsingIdentifier =
    when
        Cpp.UsingDeclaration.is(&ud)
        and ud.identifier(&id)
        and id.nodeText(&txt)
    raise "UsingDeclaration.identifier matched: '{txt}'"
    on ud

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

The predicate qualifiedIdentifier retrieves the fully qualified identifier in a C++ using declaration.

Example C++ code:

using std::vector;

Equivalent tree-sitter node:

(using_declaration 
   (qualified_identifier 
      (namespace_identifier) 
      (identifier)))

The qualifiedIdentifier predicate matches the qualified name std::vector in the using declaration. This allows static analysis to identify the exact symbol being imported.

This example demonstrates using UsingDeclaration.qualifiedIdentifier to match a using declaration that refers to a qualified name (e.g. "std::vector"). The C++ snippet below would trigger the rule because it contains a using declaration that names a qualified identifier.

#include <vector>
using std::vector;

void foo() {
    vector<int> v;
}

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

Version History

Introduced in R2026a