use std::collections::HashMap;
use std::sync::OnceLock;
use streaming_iterator::StreamingIterator;
use tree_sitter::{Language, Node, Query, QueryCursor};
use crate::domain::{LanguageId, ReferenceKind, ReferenceRecord};
const RUST_XREF_QUERY: &str = r#"
; Simple function calls: foo()
(call_expression function: (identifier) @ref.call)
; Qualified calls: Vec::new() — capture the scoped_identifier for qualified_name too
(call_expression function: (scoped_identifier name: (identifier) @ref.call) @ref.qualified_call)
; Method calls: self.push()
(call_expression function: (field_expression field: (field_identifier) @ref.method_call))
; Macro invocations: println!()
(macro_invocation macro: (identifier) @ref.macro)
; Use declarations: use std::collections::HashMap
(use_declaration argument: (identifier) @ref.import)
(use_declaration argument: (scoped_identifier) @ref.import)
(use_declaration argument: (use_list) @ref.import)
(use_declaration argument: (scoped_use_list) @ref.import)
; Import with alias: use HashMap as Map
(use_as_clause path: (_) @import.original alias: (identifier) @import.alias)
; Type references (in function params, return types, struct fields, etc.)
(type_identifier) @ref.type
; Trait implementations: impl Trait for Struct
(impl_item trait: (type_identifier) @ref.implements type: (type_identifier) @ref.implements_target)
(impl_item trait: (scoped_type_identifier) @ref.implements type: (type_identifier) @ref.implements_target)
(impl_item trait: (generic_type) @ref.implements type: (type_identifier) @ref.implements_target)
"#;
const PYTHON_XREF_QUERY: &str = r#"
; Function calls: foo(x)
(call function: (identifier) @ref.call)
; Method calls: obj.method()
(call function: (attribute attribute: (identifier) @ref.method_call))
; Import statements: import os
(import_statement name: (dotted_name (identifier) @ref.import))
; From imports: from os import path
(import_from_statement module_name: (dotted_name (identifier) @ref.import))
(import_from_statement name: (dotted_name (identifier) @ref.import))
; Import alias: import numpy as np
(aliased_import name: (dotted_name (identifier) @import.original) alias: (identifier) @import.alias)
; Type annotations: x: MyType
(type (identifier) @ref.type)
; Class inheritance: class Foo(Base)
(class_definition
name: (identifier) @ref.implements_target
superclasses: (argument_list (identifier) @ref.implements))
"#;
const JS_XREF_QUERY: &str = r#"
; Function calls: foo()
(call_expression function: (identifier) @ref.call)
; Method calls: obj.method()
(call_expression function: (member_expression property: (property_identifier) @ref.method_call))
; Constructor: new Foo()
(new_expression constructor: (identifier) @ref.call)
; Import statements: import React from 'react'
(import_statement source: (string) @ref.import)
; Import specifiers: import { Component } from 'react'
(import_specifier name: (identifier) @ref.import)
"#;
const TS_XREF_QUERY: &str = r#"
; Function calls: foo()
(call_expression function: (identifier) @ref.call)
; Method calls: obj.method()
(call_expression function: (member_expression property: (property_identifier) @ref.method_call))
; Constructor: new Foo()
(new_expression constructor: (identifier) @ref.call)
; Import statements: import React from 'react'
(import_statement source: (string) @ref.import)
; Import specifiers: import { Component } from 'react'
(import_specifier name: (identifier) @ref.import)
; TypeScript type references: param: MyType
(type_identifier) @ref.type
; Class implements: class Foo implements Bar
(class_declaration
name: (type_identifier) @ref.implements_target
(class_heritage
(implements_clause
(type_identifier) @ref.implements)))
; Class extends: class Foo extends Bar
(class_declaration
name: (type_identifier) @ref.implements_target
(class_heritage
(extends_clause
value: (identifier) @ref.implements)))
"#;
const GO_XREF_QUERY: &str = r#"
; Simple function calls: foo()
(call_expression function: (identifier) @ref.call)
; Selector calls: fmt.Println()
(call_expression function: (selector_expression field: (field_identifier) @ref.method_call))
; Import specs: import "fmt"
(import_spec path: (interpreted_string_literal) @ref.import)
; Type references
(type_identifier) @ref.type
"#;
const JAVA_XREF_QUERY: &str = r#"
; Method invocations: obj.println()
(method_invocation name: (identifier) @ref.call)
; Object creation: new ArrayList()
(object_creation_expression type: (type_identifier) @ref.call)
; Import declarations: import java.util.ArrayList
(import_declaration (scoped_identifier) @ref.import)
; Type references
(type_identifier) @ref.type
; Class implements: class Foo implements Bar
(class_declaration
name: (identifier) @ref.implements_target
interfaces: (super_interfaces
(type_list (type_identifier) @ref.implements)))
; Class extends: class Foo extends Bar
(class_declaration
name: (identifier) @ref.implements_target
superclass: (superclass (type_identifier) @ref.implements))
"#;
const C_XREF_QUERY: &str = r#"
; Function calls: foo()
(call_expression function: (identifier) @ref.call)
; Method/field calls: obj->method() or obj.field()
(call_expression function: (field_expression field: (field_identifier) @ref.method_call))
; #include imports: "header.h" or <stdio.h>
(preproc_include path: (string_literal) @ref.import)
(preproc_include path: (system_lib_string) @ref.import)
; Type identifiers: MyStruct, typedef'd names
(type_identifier) @ref.type
"#;
const CPP_XREF_QUERY: &str = r#"
; Function calls: foo()
(call_expression function: (identifier) @ref.call)
; Method calls: obj.method() or obj->method()
(call_expression function: (field_expression field: (field_identifier) @ref.method_call))
; Qualified calls: std::sort, Foo::bar
(qualified_identifier name: (identifier) @ref.call)
; #include imports
(preproc_include path: (string_literal) @ref.import)
(preproc_include path: (system_lib_string) @ref.import)
; Type identifiers
(type_identifier) @ref.type
; Template instantiation: vector<int>
(template_type name: (type_identifier) @ref.type)
; Using declarations: using std::string
(using_declaration (qualified_identifier) @import.original)
; Class inheritance: class Foo : public Bar
(class_specifier
name: (type_identifier) @ref.implements_target
(base_class_clause
(type_identifier) @ref.implements))
"#;
const CSHARP_XREF_QUERY: &str = r#"
; Method invocations: obj.Method() — capture the method name
(invocation_expression
(member_access_expression name: (identifier) @ref.method_call))
; Simple function calls: foo()
(invocation_expression
function: (identifier) @ref.call)
; Object creation: new Foo()
(object_creation_expression type: (identifier) @ref.call)
; Using directives: keep the full namespace/type text when present.
(using_directive (qualified_name) @ref.import)
(using_directive (alias_qualified_name) @ref.import)
(using_directive (generic_name) @ref.import)
(using_directive (identifier) @ref.import)
; Type references in DI-style constructor params, fields, properties, and return types.
(parameter type: (type) @ref.type)
(variable_declaration type: (type) @ref.type)
(property_declaration type: (type) @ref.type)
; Class implements/extends: class Foo : IBar, Base
(class_declaration
name: (identifier) @ref.implements_target
(base_list (identifier) @ref.implements))
(class_declaration
name: (identifier) @ref.implements_target
(base_list (qualified_name) @ref.implements))
(class_declaration
name: (identifier) @ref.implements_target
(base_list (generic_name) @ref.implements))
"#;
const RUBY_XREF_QUERY: &str = r#"
; Method calls: foo() or object.method()
(call receiver: (_) method: (identifier) @ref.method_call)
(call method: (identifier) @ref.call)
; Require/require_relative
(call method: (identifier) @ref.import
(#match? @ref.import "^require"))
; Constant references: MyClass, MY_CONST
(constant) @ref.type
; Class inheritance: class Foo < Bar
(class
name: (constant) @ref.implements_target
(superclass (constant) @ref.implements))
(class
name: (constant) @ref.implements_target
(superclass (scope_resolution) @ref.implements))
"#;
const KOTLIN_XREF_QUERY: &str = r#"
; Function/method calls: foo() or obj.method()
(call_expression (simple_identifier) @ref.call)
(navigation_expression (simple_identifier) @ref.method_call)
; Import directives
(import_header (identifier) @ref.import)
; Type references
(user_type (type_identifier) @ref.type)
"#;
const DART_XREF_QUERY: &str = r#"
; Function/method calls: print('x') or obj.method()
; In dart grammar, calls are member_access with selector
(member_access (identifier) @ref.call)
; Import directives: import 'dart:core'
; import_specification -> configurable_uri -> uri -> string_literal
(import_specification (configurable_uri (uri (string_literal) @ref.import)))
; Type identifiers
(type_identifier) @ref.type
"#;
const ELIXIR_XREF_QUERY: &str = r#"
; Function calls: Module.function()
(call target: (dot left: (alias) right: (identifier) @ref.method_call))
; Local function calls: my_func()
(call target: (identifier) @ref.call)
; alias/import/use module references — capture the module alias
(call target: (identifier)
(arguments (alias) @ref.import))
"#;
const PHP_XREF_QUERY: &str = r#"
; Function calls: foo() — function: can be qualified_name or variable_name
(function_call_expression
function: (qualified_name (name) @ref.call))
; Method calls: $obj->method()
(member_call_expression
name: (name) @ref.method_call)
; Static calls: Foo::bar()
(scoped_call_expression
name: (name) @ref.method_call)
; Type references in class extends/implements
(named_type (name) @ref.type)
; Class implements: class Foo implements Bar
(class_declaration
name: (name) @ref.implements_target
(class_interface_clause (name) @ref.implements))
; Class extends: class Foo extends Bar
(class_declaration
name: (name) @ref.implements_target
(base_clause (name) @ref.implements))
"#;
const SWIFT_XREF_QUERY: &str = r#"
; Navigation expression method calls: obj.method()
(navigation_expression
(simple_identifier) @ref.method_call)
; Import declarations: import Foundation
(import_declaration
(identifier) @ref.import)
; Type references
(user_type
(type_identifier) @ref.type)
; Protocol conformance: class Foo: Bar, Protocol
(class_declaration
name: (type_identifier) @ref.implements_target
(inheritance_specifier
(user_type (type_identifier) @ref.implements)))
"#;
const PERL_XREF_QUERY: &str = r#"
; Method calls: $obj->method()
(method_invocation
function_name: (identifier) @ref.method_call)
; require statements
(require_statement
package_name: (package_name) @ref.import)
"#;
static RUST_QUERY: OnceLock<Query> = OnceLock::new();
static PYTHON_QUERY: OnceLock<Query> = OnceLock::new();
static JS_QUERY: OnceLock<Query> = OnceLock::new();
static TS_QUERY: OnceLock<Query> = OnceLock::new();
static GO_QUERY: OnceLock<Query> = OnceLock::new();
static JAVA_QUERY: OnceLock<Query> = OnceLock::new();
static C_QUERY: OnceLock<Query> = OnceLock::new();
static CPP_QUERY: OnceLock<Query> = OnceLock::new();
static CSHARP_QUERY: OnceLock<Query> = OnceLock::new();
static RUBY_QUERY: OnceLock<Query> = OnceLock::new();
static KOTLIN_QUERY: OnceLock<Query> = OnceLock::new();
static DART_QUERY: OnceLock<Query> = OnceLock::new();
static ELIXIR_QUERY: OnceLock<Query> = OnceLock::new();
static PHP_QUERY: OnceLock<Query> = OnceLock::new();
static SWIFT_QUERY: OnceLock<Query> = OnceLock::new();
static PERL_QUERY: OnceLock<Query> = OnceLock::new();
fn rust_query(lang: &Language) -> &'static Query {
RUST_QUERY.get_or_init(|| Query::new(lang, RUST_XREF_QUERY).expect("valid rust xref query"))
}
fn python_query(lang: &Language) -> &'static Query {
PYTHON_QUERY
.get_or_init(|| Query::new(lang, PYTHON_XREF_QUERY).expect("valid python xref query"))
}
fn js_query(lang: &Language) -> &'static Query {
JS_QUERY.get_or_init(|| Query::new(lang, JS_XREF_QUERY).expect("valid js xref query"))
}
fn ts_query(lang: &Language) -> &'static Query {
TS_QUERY.get_or_init(|| Query::new(lang, TS_XREF_QUERY).expect("valid ts xref query"))
}
fn go_query(lang: &Language) -> &'static Query {
GO_QUERY.get_or_init(|| Query::new(lang, GO_XREF_QUERY).expect("valid go xref query"))
}
fn java_query(lang: &Language) -> &'static Query {
JAVA_QUERY.get_or_init(|| Query::new(lang, JAVA_XREF_QUERY).expect("valid java xref query"))
}
fn c_query(lang: &Language) -> &'static Query {
C_QUERY.get_or_init(|| Query::new(lang, C_XREF_QUERY).expect("valid c xref query"))
}
fn cpp_query(lang: &Language) -> &'static Query {
CPP_QUERY.get_or_init(|| Query::new(lang, CPP_XREF_QUERY).expect("valid cpp xref query"))
}
fn csharp_query(lang: &Language) -> &'static Query {
CSHARP_QUERY
.get_or_init(|| Query::new(lang, CSHARP_XREF_QUERY).expect("valid csharp xref query"))
}
fn ruby_query(lang: &Language) -> &'static Query {
RUBY_QUERY.get_or_init(|| Query::new(lang, RUBY_XREF_QUERY).expect("valid ruby xref query"))
}
fn kotlin_query(lang: &Language) -> &'static Query {
KOTLIN_QUERY
.get_or_init(|| Query::new(lang, KOTLIN_XREF_QUERY).expect("valid kotlin xref query"))
}
fn dart_query(lang: &Language) -> &'static Query {
DART_QUERY.get_or_init(|| Query::new(lang, DART_XREF_QUERY).expect("valid dart xref query"))
}
fn elixir_query(lang: &Language) -> &'static Query {
ELIXIR_QUERY
.get_or_init(|| Query::new(lang, ELIXIR_XREF_QUERY).expect("valid elixir xref query"))
}
fn php_query(lang: &Language) -> &'static Query {
PHP_QUERY.get_or_init(|| Query::new(lang, PHP_XREF_QUERY).expect("valid php xref query"))
}
fn swift_query(lang: &Language) -> &'static Query {
SWIFT_QUERY.get_or_init(|| Query::new(lang, SWIFT_XREF_QUERY).expect("valid swift xref query"))
}
fn perl_query(lang: &Language) -> &'static Query {
PERL_QUERY.get_or_init(|| Query::new(lang, PERL_XREF_QUERY).expect("valid perl xref query"))
}
fn split_top_level_rust_items(input: &str) -> Vec<&str> {
let mut parts = Vec::new();
let mut depth = 0usize;
let mut start = 0usize;
for (idx, ch) in input.char_indices() {
match ch {
'{' => depth += 1,
'}' => depth = depth.saturating_sub(1),
',' if depth == 0 => {
parts.push(input[start..idx].trim());
start = idx + ch.len_utf8();
}
_ => {}
}
}
if start <= input.len() {
parts.push(input[start..].trim());
}
parts.into_iter().filter(|part| !part.is_empty()).collect()
}
fn rust_grouped_import_parts(input: &str) -> Option<(&str, &str)> {
let trimmed = input.trim();
let brace_start = trimmed.find('{')?;
let brace_end = trimmed.rfind('}')?;
if brace_end <= brace_start {
return None;
}
let prefix = trimmed[..brace_start].trim_end().trim_end_matches("::");
let inner = &trimmed[brace_start + 1..brace_end];
Some((prefix, inner))
}
fn expand_rust_import_paths(input: &str) -> Vec<String> {
let trimmed = input.trim();
let alias_free = trimmed
.split_once(" as ")
.map(|(original, _)| original.trim())
.unwrap_or(trimmed);
if let Some((prefix, inner)) = rust_grouped_import_parts(alias_free) {
return split_top_level_rust_items(inner)
.into_iter()
.flat_map(|item| {
let combined = if prefix.is_empty() {
item.to_string()
} else {
format!("{prefix}::{item}")
};
expand_rust_import_paths(&combined)
})
.collect();
}
vec![alias_free.to_string()]
}
fn push_import_reference(
references: &mut Vec<ReferenceRecord>,
import_text: &str,
import_node: Node,
) {
let full_text = import_text.trim();
let name = if full_text.contains('/') && !full_text.contains("::") {
full_text.split('/').next_back().unwrap_or(full_text)
} else {
full_text
.split("::")
.last()
.or_else(|| full_text.split('.').next_back())
.unwrap_or(full_text)
};
let name = name.trim_matches('"').trim_matches('\'').to_string();
if name.is_empty() {
return;
}
let qualified_name = if full_text.contains("::") || full_text.contains('.') {
Some(full_text.to_string())
} else {
None
};
let start = import_node.start_position();
let end = import_node.end_position();
references.push(ReferenceRecord {
name,
qualified_name,
kind: ReferenceKind::Import,
byte_range: (
import_node.start_byte() as u32,
import_node.end_byte() as u32,
),
line_range: (start.row as u32, end.row as u32),
enclosing_symbol_index: None,
});
}
pub fn extract_references(
root: &Node,
source: &str,
language: &LanguageId,
) -> (Vec<ReferenceRecord>, HashMap<String, String>) {
let source_bytes = source.as_bytes();
let (query, ts_language) = match language {
LanguageId::Rust => {
let lang: Language = tree_sitter_rust::LANGUAGE.into();
(rust_query(&lang), lang)
}
LanguageId::Python => {
let lang: Language = tree_sitter_python::LANGUAGE.into();
(python_query(&lang), lang)
}
LanguageId::JavaScript => {
let lang: Language = tree_sitter_javascript::LANGUAGE.into();
(js_query(&lang), lang)
}
LanguageId::TypeScript => {
let lang: Language = tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into();
(ts_query(&lang), lang)
}
LanguageId::Go => {
let lang: Language = tree_sitter_go::LANGUAGE.into();
(go_query(&lang), lang)
}
LanguageId::Java => {
let lang: Language = tree_sitter_java::LANGUAGE.into();
(java_query(&lang), lang)
}
LanguageId::C => {
let lang: Language = tree_sitter_c::LANGUAGE.into();
(c_query(&lang), lang)
}
LanguageId::Cpp => {
let lang: Language = tree_sitter_cpp::LANGUAGE.into();
(cpp_query(&lang), lang)
}
LanguageId::CSharp => {
let lang: Language = tree_sitter_c_sharp::LANGUAGE.into();
(csharp_query(&lang), lang)
}
LanguageId::Ruby => {
let lang: Language = tree_sitter_ruby::LANGUAGE.into();
(ruby_query(&lang), lang)
}
LanguageId::Kotlin => {
let lang: Language = tree_sitter_kotlin_sg::LANGUAGE.into();
(kotlin_query(&lang), lang)
}
LanguageId::Dart => {
let lang: Language = tree_sitter_dart::language();
(dart_query(&lang), lang)
}
LanguageId::Elixir => {
let lang: Language = tree_sitter_elixir::LANGUAGE.into();
(elixir_query(&lang), lang)
}
LanguageId::Php => {
let lang: Language = tree_sitter_php::LANGUAGE_PHP.into();
(php_query(&lang), lang)
}
LanguageId::Swift => {
let lang: Language = tree_sitter_swift::LANGUAGE.into();
(swift_query(&lang), lang)
}
LanguageId::Perl => {
let lang: Language = tree_sitter_perl::LANGUAGE.into();
(perl_query(&lang), lang)
}
LanguageId::Json
| LanguageId::Toml
| LanguageId::Yaml
| LanguageId::Markdown
| LanguageId::Env => unreachable!("config types are handled before extract_references"),
LanguageId::Html | LanguageId::Css | LanguageId::Scss => {
return (vec![], HashMap::new());
}
};
let _ = ts_language;
let capture_names = query.capture_names();
let mut cursor = QueryCursor::new();
let mut references: Vec<ReferenceRecord> = Vec::new();
let mut alias_map: HashMap<String, String> = HashMap::new();
let mut matches = cursor.matches(query, *root, source_bytes);
while let Some(m) = {
matches.advance();
matches.get()
} {
let mut ref_call: Option<Node> = None;
let mut ref_qualified_call: Option<Node> = None;
let mut ref_method_call: Option<Node> = None;
let mut ref_import: Option<Node> = None;
let mut ref_type: Option<Node> = None;
let mut ref_macro: Option<Node> = None;
let mut import_original: Option<Node> = None;
let mut import_alias: Option<Node> = None;
let mut ref_implements: Option<Node> = None;
let mut ref_implements_target: Option<Node> = None;
for capture in m.captures {
let name = capture_names[capture.index as usize];
let node = capture.node;
match name {
"ref.call" => {
ref_call = Some(node);
}
"ref.qualified_call" => {
ref_qualified_call = Some(node);
}
"ref.method_call" => {
ref_method_call = Some(node);
}
"ref.import" => {
ref_import = Some(node);
}
"ref.type" => {
ref_type = Some(node);
}
"ref.macro" => {
ref_macro = Some(node);
}
"import.original" => {
import_original = Some(node);
}
"import.alias" => {
import_alias = Some(node);
}
"ref.implements" => {
ref_implements = Some(node);
}
"ref.implements_target" => {
ref_implements_target = Some(node);
}
_ => {}
}
}
if let (Some(orig_node), Some(alias_node)) = (import_original, import_alias) {
if let (Ok(orig_text), Ok(alias_text)) = (
orig_node.utf8_text(source_bytes),
alias_node.utf8_text(source_bytes),
) {
let orig_name = orig_text
.split("::")
.last()
.unwrap_or(orig_text)
.trim()
.to_string();
let alias_str = alias_text.trim().to_string();
alias_map.insert(alias_str, orig_name);
}
continue;
}
if let Some(call_node) = ref_call
&& let Ok(name_text) = call_node.utf8_text(source_bytes)
{
let name = name_text.trim().to_string();
let qualified_name = if let Some(qual_node) = ref_qualified_call {
qual_node
.utf8_text(source_bytes)
.ok()
.map(|t| t.trim().to_string())
} else {
None
};
let start = call_node.start_position();
let end = call_node.end_position();
references.push(ReferenceRecord {
name,
qualified_name,
kind: ReferenceKind::Call,
byte_range: (call_node.start_byte() as u32, call_node.end_byte() as u32),
line_range: (start.row as u32, end.row as u32),
enclosing_symbol_index: None,
});
}
if let Some(method_node) = ref_method_call
&& let Ok(name_text) = method_node.utf8_text(source_bytes)
{
let name = name_text.trim().to_string();
let start = method_node.start_position();
let end = method_node.end_position();
references.push(ReferenceRecord {
name,
qualified_name: None,
kind: ReferenceKind::Call,
byte_range: (
method_node.start_byte() as u32,
method_node.end_byte() as u32,
),
line_range: (start.row as u32, end.row as u32),
enclosing_symbol_index: None,
});
}
if let Some(import_node) = ref_import
&& let Ok(name_text) = import_node.utf8_text(source_bytes)
{
let import_texts = match language {
LanguageId::Rust => expand_rust_import_paths(name_text),
_ => vec![name_text.trim().to_string()],
};
for import_text in import_texts {
push_import_reference(&mut references, &import_text, import_node);
}
}
if let Some(type_node) = ref_type
&& let Ok(name_text) = type_node.utf8_text(source_bytes)
{
let name = name_text.trim().to_string();
if !name.is_empty() {
let start = type_node.start_position();
let end = type_node.end_position();
references.push(ReferenceRecord {
name,
qualified_name: None,
kind: ReferenceKind::TypeUsage,
byte_range: (type_node.start_byte() as u32, type_node.end_byte() as u32),
line_range: (start.row as u32, end.row as u32),
enclosing_symbol_index: None,
});
}
}
if let Some(macro_node) = ref_macro
&& let Ok(name_text) = macro_node.utf8_text(source_bytes)
{
let name = name_text.trim().to_string();
if !name.is_empty() {
let start = macro_node.start_position();
let end = macro_node.end_position();
references.push(ReferenceRecord {
name,
qualified_name: None,
kind: ReferenceKind::MacroUse,
byte_range: (macro_node.start_byte() as u32, macro_node.end_byte() as u32),
line_range: (start.row as u32, end.row as u32),
enclosing_symbol_index: None,
});
}
}
if let (Some(impl_node), Some(target_node)) = (ref_implements, ref_implements_target)
&& let Ok(impl_text) = impl_node.utf8_text(source_bytes)
&& let Ok(target_text) = target_node.utf8_text(source_bytes)
{
let trait_name = impl_text.trim().to_string();
let implementor = target_text.trim().to_string();
if !trait_name.is_empty() && !implementor.is_empty() {
let start = impl_node.start_position();
let end = impl_node.end_position();
references.push(ReferenceRecord {
name: trait_name,
qualified_name: Some(implementor),
kind: ReferenceKind::Implements,
byte_range: (impl_node.start_byte() as u32, impl_node.end_byte() as u32),
line_range: (start.row as u32, end.row as u32),
enclosing_symbol_index: None,
});
}
}
}
(references, alias_map)
}
#[cfg(test)]
mod tests {
use super::*;
use tree_sitter::Parser;
fn parse_and_extract(
source: &str,
language: LanguageId,
) -> (Vec<ReferenceRecord>, HashMap<String, String>) {
let mut parser = Parser::new();
let ts_language: Language = match &language {
LanguageId::Rust => tree_sitter_rust::LANGUAGE.into(),
LanguageId::Python => tree_sitter_python::LANGUAGE.into(),
LanguageId::JavaScript => tree_sitter_javascript::LANGUAGE.into(),
LanguageId::TypeScript => tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into(),
LanguageId::Go => tree_sitter_go::LANGUAGE.into(),
LanguageId::Java => tree_sitter_java::LANGUAGE.into(),
LanguageId::C => tree_sitter_c::LANGUAGE.into(),
LanguageId::Cpp => tree_sitter_cpp::LANGUAGE.into(),
LanguageId::CSharp => tree_sitter_c_sharp::LANGUAGE.into(),
LanguageId::Ruby => tree_sitter_ruby::LANGUAGE.into(),
LanguageId::Kotlin => tree_sitter_kotlin_sg::LANGUAGE.into(),
LanguageId::Dart => tree_sitter_dart::language(),
LanguageId::Elixir => tree_sitter_elixir::LANGUAGE.into(),
LanguageId::Php => tree_sitter_php::LANGUAGE_PHP.into(),
LanguageId::Swift => tree_sitter_swift::LANGUAGE.into(),
LanguageId::Perl => tree_sitter_perl::LANGUAGE.into(),
LanguageId::Json
| LanguageId::Toml
| LanguageId::Yaml
| LanguageId::Markdown
| LanguageId::Env
| LanguageId::Html
| LanguageId::Css
| LanguageId::Scss => {
unreachable!("config/frontend languages don't use tree-sitter xref extraction")
}
};
parser.set_language(&ts_language).expect("set language");
let tree = parser.parse(source, None).expect("parse");
let root = tree.root_node();
extract_references(&root, source, &language)
}
fn find_ref<'a>(refs: &'a [ReferenceRecord], name: &str) -> Option<&'a ReferenceRecord> {
refs.iter().find(|r| r.name == name)
}
fn has_ref(refs: &[ReferenceRecord], name: &str, kind: ReferenceKind) -> bool {
refs.iter().any(|r| r.name == name && r.kind == kind)
}
#[test]
fn test_rust_call_expression_simple() {
let (refs, _) = parse_and_extract("fn main() { foo(); }", LanguageId::Rust);
assert!(
has_ref(&refs, "foo", ReferenceKind::Call),
"refs: {:?}",
refs
);
}
#[test]
fn test_rust_scoped_identifier_qualified_call() {
let (refs, _) = parse_and_extract("fn main() { Vec::new(); }", LanguageId::Rust);
let r = find_ref(&refs, "new");
assert!(r.is_some(), "should find 'new' call, refs: {:?}", refs);
let r = r.unwrap();
assert_eq!(r.kind, ReferenceKind::Call);
assert!(r.qualified_name.is_some(), "should have qualified_name");
let qname = r.qualified_name.as_deref().unwrap();
assert!(
qname.contains("Vec"),
"qualified_name should contain Vec, got: {qname}"
);
}
#[test]
fn test_rust_method_call() {
let (refs, _) = parse_and_extract("fn main() { self.items.push(x); }", LanguageId::Rust);
assert!(
has_ref(&refs, "push", ReferenceKind::Call),
"refs: {:?}",
refs
);
}
#[test]
fn test_rust_macro_invocation() {
let (refs, _) = parse_and_extract(r#"fn main() { println!("hi"); }"#, LanguageId::Rust);
assert!(
has_ref(&refs, "println", ReferenceKind::MacroUse),
"refs: {:?}",
refs
);
}
#[test]
fn test_rust_use_declaration_import() {
let (refs, _) = parse_and_extract("use std::collections::HashMap;", LanguageId::Rust);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have at least one Import ref, refs: {:?}",
refs
);
}
#[test]
fn test_rust_grouped_use_declaration_expands_imports() {
let (refs, _) = parse_and_extract("use crate::{daemon, other};", LanguageId::Rust);
assert!(
refs.iter().any(|r| {
r.kind == ReferenceKind::Import
&& r.name == "daemon"
&& r.qualified_name.as_deref() == Some("crate::daemon")
}),
"grouped Rust imports should include crate::daemon, refs: {:?}",
refs
);
assert!(
refs.iter().any(|r| {
r.kind == ReferenceKind::Import
&& r.name == "other"
&& r.qualified_name.as_deref() == Some("crate::other")
}),
"grouped Rust imports should include crate::other, refs: {:?}",
refs
);
}
#[test]
fn test_rust_use_as_clause_populates_alias_map() {
let source = "use std::collections::HashMap as Map;";
let (_, alias_map) = parse_and_extract(source, LanguageId::Rust);
assert!(
alias_map.contains_key("Map"),
"alias_map should contain 'Map', got: {:?}",
alias_map
);
assert_eq!(alias_map.get("Map").map(|s| s.as_str()), Some("HashMap"));
}
#[test]
fn test_rust_type_identifier() {
let (refs, _) = parse_and_extract("fn foo(param: MyStruct) {}", LanguageId::Rust);
assert!(
has_ref(&refs, "MyStruct", ReferenceKind::TypeUsage),
"refs: {:?}",
refs
);
}
#[test]
fn test_rust_impl_trait_for_struct() {
let source = r#"
struct MyStruct;
trait Display {}
impl Display for MyStruct {}
"#;
let (refs, _) = parse_and_extract(source, LanguageId::Rust);
let impl_refs: Vec<_> = refs
.iter()
.filter(|r| r.kind == ReferenceKind::Implements)
.collect();
assert_eq!(
impl_refs.len(),
1,
"should find 1 implements ref, got: {:?}",
impl_refs
);
assert_eq!(impl_refs[0].name, "Display");
assert_eq!(impl_refs[0].qualified_name.as_deref(), Some("MyStruct"));
}
#[test]
fn test_rust_impl_scoped_trait_for_struct() {
let source = r#"
struct Foo;
impl std::fmt::Display for Foo {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { Ok(()) }
}
"#;
let (refs, _) = parse_and_extract(source, LanguageId::Rust);
let impl_refs: Vec<_> = refs
.iter()
.filter(|r| r.kind == ReferenceKind::Implements)
.collect();
assert_eq!(
impl_refs.len(),
1,
"should find 1 implements ref, got: {:?}",
impl_refs
);
assert!(
impl_refs[0].name.contains("Display"),
"trait name should contain Display, got: {}",
impl_refs[0].name
);
assert_eq!(impl_refs[0].qualified_name.as_deref(), Some("Foo"));
}
#[test]
fn test_python_class_inheritance() {
let source = "class Dog(Animal):\n pass";
let (refs, _) = parse_and_extract(source, LanguageId::Python);
let impl_refs: Vec<_> = refs
.iter()
.filter(|r| r.kind == ReferenceKind::Implements)
.collect();
assert_eq!(
impl_refs.len(),
1,
"should find 1 implements ref, got: {:?}",
impl_refs
);
assert_eq!(impl_refs[0].name, "Animal");
assert_eq!(impl_refs[0].qualified_name.as_deref(), Some("Dog"));
}
#[test]
fn test_ts_class_implements() {
let source = "class Foo implements Bar {}";
let (refs, _) = parse_and_extract(source, LanguageId::TypeScript);
let impl_refs: Vec<_> = refs
.iter()
.filter(|r| r.kind == ReferenceKind::Implements)
.collect();
assert!(
impl_refs
.iter()
.any(|r| r.name == "Bar" && r.qualified_name.as_deref() == Some("Foo")),
"should find Foo implements Bar, got: {:?}",
impl_refs
);
}
#[test]
fn test_csharp_class_base_list() {
let source = "class MyService : IService {}";
let (refs, _) = parse_and_extract(source, LanguageId::CSharp);
let impl_refs: Vec<_> = refs
.iter()
.filter(|r| r.kind == ReferenceKind::Implements)
.collect();
assert!(
impl_refs
.iter()
.any(|r| r.name == "IService" && r.qualified_name.as_deref() == Some("MyService")),
"should find MyService : IService, got: {:?}",
impl_refs
);
}
#[test]
fn test_java_class_implements() {
let source = "class Foo implements Runnable {}";
let (refs, _) = parse_and_extract(source, LanguageId::Java);
let impl_refs: Vec<_> = refs
.iter()
.filter(|r| r.kind == ReferenceKind::Implements)
.collect();
assert!(
impl_refs
.iter()
.any(|r| r.name == "Runnable" && r.qualified_name.as_deref() == Some("Foo")),
"should find Foo implements Runnable, got: {:?}",
impl_refs
);
}
#[test]
fn test_python_function_call() {
let (refs, _) = parse_and_extract("process(data)", LanguageId::Python);
assert!(
has_ref(&refs, "process", ReferenceKind::Call),
"refs: {:?}",
refs
);
}
#[test]
fn test_python_import_statement() {
let (refs, _) = parse_and_extract("import os", LanguageId::Python);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref, refs: {:?}",
refs
);
}
#[test]
fn test_python_from_import() {
let (refs, _) = parse_and_extract("from os import path", LanguageId::Python);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref, refs: {:?}",
refs
);
}
#[test]
fn test_python_type_annotation() {
let (refs, _) = parse_and_extract("def foo(x: MyType): pass", LanguageId::Python);
assert!(
has_ref(&refs, "MyType", ReferenceKind::TypeUsage),
"refs: {:?}",
refs
);
}
#[test]
fn test_js_call_expression() {
let (refs, _) = parse_and_extract("fetch(url);", LanguageId::JavaScript);
assert!(
has_ref(&refs, "fetch", ReferenceKind::Call),
"refs: {:?}",
refs
);
}
#[test]
fn test_js_import_statement() {
let (refs, _) = parse_and_extract("import React from 'react';", LanguageId::JavaScript);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref, refs: {:?}",
refs
);
}
#[test]
fn test_ts_type_references() {
let source = "interface Foo { bar: MyInterface; }";
let (refs, _) = parse_and_extract(source, LanguageId::TypeScript);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::TypeUsage),
"should have TypeUsage ref, refs: {:?}",
refs
);
}
#[test]
fn test_go_call_expression() {
let source = "package main\nimport \"fmt\"\nfunc main() { fmt.Println(\"hi\") }";
let (refs, _) = parse_and_extract(source, LanguageId::Go);
assert!(
has_ref(&refs, "Println", ReferenceKind::Call),
"refs: {:?}",
refs
);
}
#[test]
fn test_go_import() {
let source = "package main\nimport \"fmt\"";
let (refs, _) = parse_and_extract(source, LanguageId::Go);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref, refs: {:?}",
refs
);
}
#[test]
fn test_java_method_invocation() {
let source = "class A { void f() { System.out.println(\"hi\"); } }";
let (refs, _) = parse_and_extract(source, LanguageId::Java);
assert!(
has_ref(&refs, "println", ReferenceKind::Call),
"refs: {:?}",
refs
);
}
#[test]
fn test_java_import() {
let source = "import java.util.ArrayList;";
let (refs, _) = parse_and_extract(source, LanguageId::Java);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref, refs: {:?}",
refs
);
}
#[test]
fn test_c_call_ref() {
let source = "void foo() { bar(); }";
let (refs, _) = parse_and_extract(source, LanguageId::C);
assert!(
has_ref(&refs, "bar", ReferenceKind::Call),
"refs: {:?}",
refs
);
}
#[test]
fn test_c_include_ref() {
let source = "#include <stdio.h>\nvoid foo() {}";
let (refs, _) = parse_and_extract(source, LanguageId::C);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref for #include, refs: {:?}",
refs
);
}
#[test]
fn test_c_type_ref() {
let source = "void foo(MyStruct *s) {}";
let (refs, _) = parse_and_extract(source, LanguageId::C);
assert!(
has_ref(&refs, "MyStruct", ReferenceKind::TypeUsage),
"refs: {:?}",
refs
);
}
#[test]
fn test_c_field_method_call_ref() {
let source = "void foo(MyObj *obj) { obj->method(); }";
let (refs, _) = parse_and_extract(source, LanguageId::C);
assert!(
refs.iter()
.any(|r| r.kind == ReferenceKind::Call && r.name == "method"),
"should have method call ref, refs: {:?}",
refs
);
}
#[test]
fn test_cpp_method_call_ref() {
let source = "void foo(Foo *f) { f->bar(); }";
let (refs, _) = parse_and_extract(source, LanguageId::Cpp);
assert!(
refs.iter()
.any(|r| r.kind == ReferenceKind::Call && r.name == "bar"),
"should have method call ref, refs: {:?}",
refs
);
}
#[test]
fn test_cpp_qualified_ref() {
let source = "void foo() { std::sort(v.begin(), v.end()); }";
let (refs, _) = parse_and_extract(source, LanguageId::Cpp);
assert!(
refs.iter()
.any(|r| r.kind == ReferenceKind::Call && r.name == "sort"),
"should have qualified call ref for sort, refs: {:?}",
refs
);
}
#[test]
fn test_cpp_template_type_ref() {
let source = "void foo(std::vector<MyType> v) {}";
let (refs, _) = parse_and_extract(source, LanguageId::Cpp);
assert!(
has_ref(&refs, "MyType", ReferenceKind::TypeUsage),
"refs: {:?}",
refs
);
}
#[test]
fn test_cpp_using_declaration_import() {
let source = "using std::string;";
let (refs, _) = parse_and_extract(source, LanguageId::Cpp);
let _ = refs; }
#[test]
fn test_cpp_include_ref() {
let source = "#include <vector>\nvoid foo() {}";
let (refs, _) = parse_and_extract(source, LanguageId::Cpp);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref for #include, refs: {:?}",
refs
);
}
#[test]
fn test_all_languages_produce_at_least_one_ref_from_nontrivial_source() {
let cases: &[(&str, LanguageId)] = &[
("fn main() { println!(\"hi\"); foo(); }", LanguageId::Rust),
(
"import os\ndef main():\n os.path.join('a', 'b')",
LanguageId::Python,
),
(
"import React from 'react';\nfetch('/api');",
LanguageId::JavaScript,
),
(
"import { Component } from 'react';\nconst x: MyType = null;",
LanguageId::TypeScript,
),
(
"package main\nimport \"fmt\"\nfunc main() { fmt.Println(\"hi\") }",
LanguageId::Go,
),
(
"import java.util.ArrayList;\nclass A { void f() { new ArrayList(); } }",
LanguageId::Java,
),
("#include <stdio.h>\nvoid foo() { bar(); }", LanguageId::C),
(
"#include <vector>\nvoid foo() { std::sort(v.begin(), v.end()); }",
LanguageId::Cpp,
),
(
"using System;\npublic class App { void Run() { Console.WriteLine(\"hi\"); } }",
LanguageId::CSharp,
),
(
"require 'json'\nclass App\n def run\n puts 'hi'\n end\nend",
LanguageId::Ruby,
),
(
"import kotlin.io.*\nfun main() { println(\"hi\") }",
LanguageId::Kotlin,
),
(
"import 'dart:io';\nvoid main() { print('hello'); }",
LanguageId::Dart,
),
(
"defmodule App do\n alias MyLib.Helper\n def run, do: :ok\nend",
LanguageId::Elixir,
),
];
for (source, lang) in cases {
let (refs, _) = parse_and_extract(source, lang.clone());
assert!(
!refs.is_empty(),
"language {:?} should produce refs from non-trivial source, got none",
lang
);
}
}
#[test]
fn test_empty_source_produces_empty_refs_all_languages() {
let languages = [
LanguageId::Rust,
LanguageId::Python,
LanguageId::JavaScript,
LanguageId::TypeScript,
LanguageId::Go,
LanguageId::Java,
LanguageId::C,
LanguageId::Cpp,
LanguageId::CSharp,
LanguageId::Ruby,
LanguageId::Kotlin,
LanguageId::Dart,
LanguageId::Elixir,
];
for lang in languages {
let (refs, alias_map) = parse_and_extract("", lang.clone());
assert!(
refs.is_empty(),
"language {:?} should produce no refs from empty source",
lang
);
assert!(
alias_map.is_empty(),
"language {:?} should produce no aliases from empty source",
lang
);
}
}
#[test]
fn test_query_compilation_cached_onclock() {
let source = "fn main() { foo(); }";
let (refs1, _) = parse_and_extract(source, LanguageId::Rust);
let (refs2, _) = parse_and_extract(source, LanguageId::Rust);
assert_eq!(
refs1.len(),
refs2.len(),
"same source should produce same number of refs regardless of cache state"
);
}
#[test]
fn test_csharp_call_ref() {
let source = "public class App { void Run() { Console.WriteLine(\"hi\"); } }";
let (refs, _) = parse_and_extract(source, LanguageId::CSharp);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Call),
"should have at least one Call ref, refs: {:?}",
refs
);
}
#[test]
fn test_csharp_import_ref() {
let source = "using System.Collections.Generic;\npublic class App {}";
let (refs, _) = parse_and_extract(source, LanguageId::CSharp);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref for using directive, refs: {:?}",
refs
);
}
#[test]
fn test_csharp_import_ref_preserves_qualified_namespace() {
let source = "using CeRegistry.Core.Services;\npublic class App {}";
let (refs, _) = parse_and_extract(source, LanguageId::CSharp);
let import_ref = refs
.iter()
.find(|r| r.kind == ReferenceKind::Import)
.expect("should capture C# using directive");
assert_eq!(
import_ref.qualified_name.as_deref(),
Some("CeRegistry.Core.Services")
);
}
#[test]
fn test_csharp_type_refs_include_constructor_params_and_fields() {
let source = r#"
using CeRegistry.Core.Services;
public class PacketsController
{
private readonly IMinioService _minio;
public PacketsController(IMinioService minioService)
{
_minio = minioService;
}
}
"#;
let (refs, _) = parse_and_extract(source, LanguageId::CSharp);
let type_refs: Vec<_> = refs
.iter()
.filter(|r| r.kind == ReferenceKind::TypeUsage && r.name == "IMinioService")
.collect();
assert_eq!(
type_refs.len(),
2,
"field type and constructor parameter type should both be tracked, refs: {:?}",
refs
);
}
#[test]
fn test_ruby_call_ref() {
let source = "def run\n puts 'hello'\nend";
let (refs, _) = parse_and_extract(source, LanguageId::Ruby);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Call),
"should have at least one Call ref, refs: {:?}",
refs
);
}
#[test]
fn test_ruby_import_ref() {
let source = "require 'json'\ndef run; end";
let (refs, _) = parse_and_extract(source, LanguageId::Ruby);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref for require, refs: {:?}",
refs
);
}
#[test]
fn test_kotlin_call_ref() {
let source = "fun main() { println(\"hello\") }";
let (refs, _) = parse_and_extract(source, LanguageId::Kotlin);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Call),
"should have at least one Call ref, refs: {:?}",
refs
);
}
#[test]
fn test_kotlin_import_ref() {
let source = "import kotlin.io.println\nfun main() {}";
let (refs, _) = parse_and_extract(source, LanguageId::Kotlin);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref, refs: {:?}",
refs
);
}
#[test]
fn test_dart_import_ref() {
let source = "import 'dart:io';\nvoid main() {}";
let (refs, _) = parse_and_extract(source, LanguageId::Dart);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref for dart import, refs: {:?}",
refs
);
}
#[test]
fn test_dart_type_ref() {
let source = "class Foo { MyType field; }";
let (refs, _) = parse_and_extract(source, LanguageId::Dart);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::TypeUsage),
"should have TypeUsage ref, refs: {:?}",
refs
);
}
#[test]
fn test_elixir_call_ref() {
let source = "def run do\n IO.puts(\"hello\")\nend";
let (refs, _) = parse_and_extract(source, LanguageId::Elixir);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Call),
"should have at least one Call ref, refs: {:?}",
refs
);
}
#[test]
fn test_elixir_import_ref() {
let source = "defmodule App do\n alias MyLib.Helper\nend";
let (refs, _) = parse_and_extract(source, LanguageId::Elixir);
assert!(
refs.iter().any(|r| r.kind == ReferenceKind::Import),
"should have Import ref for alias, refs: {:?}",
refs
);
}
}