use crate::types::Language;
#[derive(Debug, Clone)]
pub struct RawReference {
pub callee: String,
pub caller: Option<String>,
pub qualifier: Option<String>,
pub line: u32,
}
const MAX_QUALIFIER_LEN: usize = 64;
fn extract_qualifier(node: &tree_sitter::Node, source: &[u8]) -> Option<String> {
let mut cursor = node.walk();
for child in node.children(&mut cursor) {
let receiver = match child.kind() {
"field_expression"
| "member_expression"
| "attribute"
| "selector_expression"
| "member_access_expression"
| "navigation_expression" => child
.child_by_field_name("object")
.or_else(|| child.child_by_field_name("value"))
.or_else(|| child.child_by_field_name("operand"))
.or_else(|| child.child(0)),
"scoped_identifier" | "qualified_identifier" => child
.child_by_field_name("path")
.or_else(|| child.child_by_field_name("scope"))
.or_else(|| child.child(0)),
_ => None,
};
let Some(receiver) = receiver else { continue };
let text = receiver.utf8_text(source).ok()?.trim();
if text.is_empty() || text.len() > MAX_QUALIFIER_LEN {
return None;
}
if text
.chars()
.all(|ch| ch.is_alphanumeric() || ch == '_' || ch == '.' || ch == ':' || ch == '$')
{
return Some(text.to_string());
}
return None;
}
None
}
pub fn extract_references(
tree: &tree_sitter::Tree,
source: &[u8],
lang: Language,
) -> Vec<RawReference> {
let symbols = super::extractor::extract_symbols(tree, source, lang);
extract_references_with_symbols(tree, source, lang, &symbols)
}
pub fn extract_references_with_symbols(
tree: &tree_sitter::Tree,
source: &[u8],
lang: Language,
symbols: &[super::extractor::RawSymbol],
) -> Vec<RawReference> {
let mut refs = Vec::new();
collect_calls(tree.root_node(), source, lang, symbols, &mut refs);
refs
}
fn is_call_node(lang: Language, kind: &str) -> bool {
match lang {
Language::Rust => matches!(kind, "call_expression" | "macro_invocation"),
Language::TypeScript | Language::JavaScript => {
matches!(kind, "call_expression" | "new_expression") || is_jsx_element_node(kind)
}
Language::Python => kind == "call",
Language::Go => kind == "call_expression",
Language::Java | Language::Kotlin | Language::CSharp => {
matches!(
kind,
"method_invocation" | "object_creation_expression" | "invocation_expression"
)
}
Language::C | Language::Cpp => kind == "call_expression",
Language::Ruby => matches!(kind, "call" | "method_call"),
Language::Swift => kind == "call_expression",
Language::Php => matches!(kind, "function_call_expression" | "method_call_expression"),
Language::Elixir => kind == "call",
Language::Scala => matches!(kind, "call_expression" | "apply_expression"),
Language::Lua | Language::Luau => kind == "function_call",
Language::Dart => matches!(kind, "function_expression_invocation" | "method_invocation"),
Language::Zig => kind == "call_expression",
Language::Haskell => kind == "function_application",
Language::Perl => kind == "function_call_expression",
Language::Julia => kind == "call_expression",
Language::OCaml => kind == "application_expression",
Language::Groovy => matches!(kind, "method_call_expression" | "function_call"),
Language::Erlang => matches!(kind, "call" | "function_call"),
Language::FSharp => kind == "application_expression",
Language::PowerShell => kind == "command_expression",
Language::R => kind == "call",
Language::DLang => kind == "call_expression",
Language::Elm => kind == "function_call_expr",
_ => false,
}
}
fn is_jsx_element_node(kind: &str) -> bool {
matches!(kind, "jsx_opening_element" | "jsx_self_closing_element")
}
fn is_jsx_host_element(node: &tree_sitter::Node, source: &[u8]) -> bool {
if !is_jsx_element_node(node.kind()) {
return false;
}
let Some(name) = node.child_by_field_name("name") else {
return false;
};
if name.kind() == "member_expression" {
return false;
}
name.utf8_text(source).is_ok_and(|text| {
text.starts_with(|ch: char| ch.is_ascii_lowercase()) || text.contains('-')
})
}
fn extract_callee(node: &tree_sitter::Node, source: &[u8]) -> Option<String> {
let mut cursor = node.walk();
for child in node.children(&mut cursor) {
match child.kind() {
"identifier" | "simple_identifier" => {
return child.utf8_text(source).ok().map(|s| s.to_string());
}
"field_expression"
| "member_expression"
| "attribute"
| "selector_expression"
| "member_access_expression"
| "navigation_expression" => {
let mut inner = child.walk();
for field_child in child.children(&mut inner) {
if matches!(
field_child.kind(),
"field_identifier"
| "property_identifier"
| "identifier"
| "simple_identifier"
) {
if let Ok(text) = field_child.utf8_text(source) {
if field_child.end_byte() == child.end_byte()
|| field_child.start_byte()
> child.start_byte() + child.byte_range().len() / 2
{
return Some(text.to_string());
}
}
}
}
if let Some(name_node) = child.child_by_field_name("field") {
return name_node.utf8_text(source).ok().map(|s| s.to_string());
}
if let Some(name_node) = child.child_by_field_name("name") {
return name_node.utf8_text(source).ok().map(|s| s.to_string());
}
}
"scoped_identifier" | "qualified_identifier" => {
let mut inner = child.walk();
let mut last_ident = None;
for sc_child in child.children(&mut inner) {
if sc_child.kind() == "identifier" || sc_child.kind() == "type_identifier" {
last_ident = sc_child.utf8_text(source).ok().map(|s| s.to_string());
}
}
return last_ident;
}
_ => {}
}
}
if let Some(func_node) = node.child_by_field_name("function") {
if func_node.kind() == "identifier" || func_node.kind() == "simple_identifier" {
return func_node.utf8_text(source).ok().map(|s| s.to_string());
}
if let Some(field) = func_node.child_by_field_name("field") {
return field.utf8_text(source).ok().map(|s| s.to_string());
}
if let Some(name) = func_node.child_by_field_name("name") {
return name.utf8_text(source).ok().map(|s| s.to_string());
}
}
if let Some(name_node) = node.child_by_field_name("name") {
return name_node.utf8_text(source).ok().map(|s| s.to_string());
}
if let Some(method_node) = node.child_by_field_name("method") {
return method_node.utf8_text(source).ok().map(|s| s.to_string());
}
None
}
fn find_enclosing_symbol(
symbols: &[super::extractor::RawSymbol],
byte_offset: usize,
) -> Option<String> {
symbols
.iter()
.filter(|s| s.start_byte <= byte_offset && byte_offset < s.end_byte)
.min_by_key(|s| s.end_byte - s.start_byte)
.and_then(|s| s.name.clone())
}
fn collect_calls(
root: tree_sitter::Node<'_>,
source: &[u8],
lang: Language,
symbols: &[super::extractor::RawSymbol],
refs: &mut Vec<RawReference>,
) {
let mut cursor = root.walk();
loop {
let node = cursor.node();
if is_call_node(lang, node.kind())
&& let Some(callee) = extract_callee(&node, source)
&& !is_jsx_host_element(&node, source)
{
let caller = find_enclosing_symbol(symbols, node.start_byte());
refs.push(RawReference {
callee,
caller,
qualifier: extract_qualifier(&node, source),
line: node.start_position().row as u32 + 1,
});
}
if cursor.goto_first_child() {
continue;
}
if cursor.goto_next_sibling() {
continue;
}
loop {
if !cursor.goto_parent() {
return;
}
if cursor.goto_next_sibling() {
break;
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::parsing::languages::tree_sitter_grammar_for_path;
use tree_sitter::Parser;
fn parse_and_extract(source: &str, lang: Language) -> Vec<RawReference> {
parse_and_extract_for_path(source, "source", lang)
}
fn parse_and_extract_for_path(source: &str, path: &str, lang: Language) -> Vec<RawReference> {
let grammar = tree_sitter_grammar_for_path(lang, path).expect("grammar should exist");
let mut parser = Parser::new();
parser.set_language(&grammar).unwrap();
let tree = parser.parse(source, None).unwrap();
extract_references(&tree, source.as_bytes(), lang)
}
#[test]
fn rust_function_calls() {
let source = r#"
fn main() {
foo();
bar::baz();
obj.method();
}
fn foo() {}
"#;
let refs = parse_and_extract(source, Language::Rust);
let callees: Vec<&str> = refs.iter().map(|r| r.callee.as_str()).collect();
assert!(
callees.contains(&"foo"),
"should find foo call: {callees:?}"
);
assert!(
refs.iter().any(|r| r.caller.as_deref() == Some("main")),
"caller should be main"
);
}
#[test]
fn python_function_calls() {
let source = r#"
def main():
foo()
bar.baz()
def foo():
pass
"#;
let refs = parse_and_extract(source, Language::Python);
let callees: Vec<&str> = refs.iter().map(|r| r.callee.as_str()).collect();
assert!(
callees.contains(&"foo"),
"should find foo call: {callees:?}"
);
}
#[test]
fn javascript_function_calls() {
let source = r#"
function main() {
foo();
obj.method();
new Bar();
}
function foo() {}
"#;
let refs = parse_and_extract(source, Language::JavaScript);
let callees: Vec<&str> = refs.iter().map(|r| r.callee.as_str()).collect();
assert!(
callees.contains(&"foo"),
"should find foo call: {callees:?}"
);
}
#[test]
fn go_function_calls() {
let source = r#"
package main
func main() {
foo()
fmt.Println("hello")
}
func foo() {}
"#;
let refs = parse_and_extract(source, Language::Go);
let callees: Vec<&str> = refs.iter().map(|r| r.callee.as_str()).collect();
assert!(
callees.contains(&"foo"),
"should find foo call: {callees:?}"
);
}
#[test]
fn tsx_jsx_elements_are_call_sites() {
let source = r#"
import { Hello } from "./jsx";
export function App() {
return (
<div className="wrap">
<Hello name="world" />
<Panel.Header title="hi"></Panel.Header>
<Icons.arrow />
<éWidget />
<My-element />
</div>
);
}
"#;
let refs = parse_and_extract_for_path(source, "src/app.tsx", Language::TypeScript);
let callees: Vec<&str> = refs.iter().map(|r| r.callee.as_str()).collect();
assert!(
callees.contains(&"Hello"),
"JSX element should be a call site: {callees:?}"
);
assert!(
callees.contains(&"Header"),
"dotted JSX element should be a call site: {callees:?}"
);
assert!(
callees.contains(&"arrow"),
"a dotted tag is a value in scope whatever the case of its \
property, so <Icons.arrow /> is a call site: {callees:?}"
);
assert!(
!callees.contains(&"div"),
"host elements should not be call sites: {callees:?}"
);
assert!(
callees.contains(&"éWidget"),
"only ASCII a-z marks an intrinsic tag, so <éWidget /> is a \
component reference: {callees:?}"
);
assert!(
!callees.contains(&"My-element"),
"a hyphen makes a tag intrinsic whatever its case, matching \
TypeScript's isIntrinsicJsxName: {callees:?}"
);
assert_eq!(
refs.iter().filter(|r| r.callee == "Header").count(),
1,
"paired tags should record one reference, not two"
);
assert!(
refs.iter()
.any(|r| r.callee == "Hello" && r.caller.as_deref() == Some("App")),
"caller should be App: {refs:?}"
);
}
#[test]
fn jsx_in_javascript_is_a_call_site() {
let source = "export function App() { return <Hello name=\"world\" />; }\n";
let refs = parse_and_extract(source, Language::JavaScript);
let callees: Vec<&str> = refs.iter().map(|r| r.callee.as_str()).collect();
assert!(
callees.contains(&"Hello"),
"JSX element should be a call site: {callees:?}"
);
}
#[test]
fn empty_source_returns_no_refs() {
let refs = parse_and_extract("", Language::Rust);
assert!(refs.is_empty());
}
fn qualifier_of<'a>(refs: &'a [RawReference], callee: &str) -> Option<&'a str> {
refs.iter()
.find(|r| r.callee == callee)
.and_then(|r| r.qualifier.as_deref())
}
#[test]
fn python_records_the_call_receiver() {
let source = "def register(app, state):\n app.add_url_rule('/')\n state.add_url_rule('/x')\n helper()\n";
let refs = parse_and_extract_for_path(source, "mod.py", Language::Python);
let receivers: Vec<Option<&str>> = refs
.iter()
.filter(|r| r.callee == "add_url_rule")
.map(|r| r.qualifier.as_deref())
.collect();
assert!(receivers.contains(&Some("app")), "{refs:?}");
assert!(receivers.contains(&Some("state")), "{refs:?}");
assert_eq!(qualifier_of(&refs, "helper"), None, "{refs:?}");
}
#[test]
fn javascript_records_dotted_receivers() {
let source = "function run(list) {\n utils.forEach(list, fn);\n list.forEach(fn);\n}\n";
let refs = parse_and_extract_for_path(source, "mod.js", Language::JavaScript);
let receivers: Vec<Option<&str>> = refs
.iter()
.filter(|r| r.callee == "forEach")
.map(|r| r.qualifier.as_deref())
.collect();
assert!(receivers.contains(&Some("utils")), "{refs:?}");
assert!(receivers.contains(&Some("list")), "{refs:?}");
}
#[test]
fn rust_records_the_path_of_a_scoped_call() {
let source = "fn main() {\n helpers::build();\n value.build();\n build();\n}\n";
let refs = parse_and_extract_for_path(source, "main.rs", Language::Rust);
let receivers: Vec<Option<&str>> = refs
.iter()
.filter(|r| r.callee == "build")
.map(|r| r.qualifier.as_deref())
.collect();
assert!(receivers.contains(&Some("helpers")), "{refs:?}");
assert!(receivers.contains(&Some("value")), "{refs:?}");
assert!(
receivers.contains(&None),
"a bare call has no receiver: {refs:?}"
);
}
#[test]
fn a_receiver_that_is_not_an_identifier_path_is_dropped() {
let source = "fn main() {\n factory().build();\n items[0].build();\n}\n";
let refs = parse_and_extract_for_path(source, "main.rs", Language::Rust);
for reference in refs.iter().filter(|r| r.callee == "build") {
assert_eq!(reference.qualifier, None, "{refs:?}");
}
}
#[test]
fn go_records_the_package_or_variable_receiver() {
let source =
"package main\n\nfunc run(r Router) {\n\tfmt.Println(\"x\")\n\tr.Handle(\"/\")\n}\n";
let refs = parse_and_extract_for_path(source, "main.go", Language::Go);
assert_eq!(qualifier_of(&refs, "Println"), Some("fmt"), "{refs:?}");
assert_eq!(qualifier_of(&refs, "Handle"), Some("r"), "{refs:?}");
}
}