Ast.UsingDeclaration Class

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

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

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

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