use std::path::{Path, PathBuf};
use tree_sitter::{Node, Parser};
use crate::errors::{Error, Result};
use crate::types::{Symbol, SymbolKind, Tier};
#[cfg(feature = "langs-extra")]
mod cpp;
#[cfg(feature = "langs-extra")]
mod go;
#[cfg(feature = "langs-extra")]
mod java;
#[cfg(feature = "langs-extra")]
mod python;
pub mod query;
mod rust;
#[cfg(feature = "langs-extra")]
mod typescript;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CallSite {
pub caller: String,
pub callee: String,
pub line: usize,
}
#[derive(Debug, Clone, Default)]
pub struct FileStructure {
pub symbols: Vec<Symbol>,
pub calls: Vec<CallSite>,
pub import_refs: Vec<String>,
}
pub(crate) struct GrammarSpec {
pub language: fn() -> tree_sitter::Language,
pub symbol_kind: fn(Node, &[u8]) -> Option<SymbolKind>,
pub symbol_name: fn(Node, &[u8]) -> Option<String>,
pub is_function_kind: fn(&str) -> bool,
pub is_call_kind: fn(&str) -> bool,
pub callee_name: fn(Node, &[u8]) -> Option<String>,
pub collect_imports: fn(Node, &[u8], &mut Vec<String>),
pub scope_name: fn(Node, &[u8]) -> Option<String>,
}
fn grammar_spec(language: &str) -> Option<GrammarSpec> {
match language {
"rust" => Some(rust::spec()),
#[cfg(feature = "langs-extra")]
"typescript" => Some(typescript::spec_typescript()),
#[cfg(feature = "langs-extra")]
"tsx" => Some(typescript::spec_tsx()),
#[cfg(feature = "langs-extra")]
"python" => Some(python::spec()),
#[cfg(feature = "langs-extra")]
"go" => Some(go::spec()),
#[cfg(feature = "langs-extra")]
"java" => Some(java::spec()),
#[cfg(feature = "langs-extra")]
"cpp" => Some(cpp::spec()),
_ => None,
}
}
#[must_use]
pub fn language_for_extension(ext: &str) -> Option<&'static str> {
let language = match ext {
"rs" => "rust",
#[cfg(feature = "langs-extra")]
"ts" | "mts" | "cts" | "js" | "mjs" | "cjs" => "typescript",
#[cfg(feature = "langs-extra")]
"tsx" | "jsx" => "tsx",
#[cfg(feature = "langs-extra")]
"py" | "pyi" => "python",
#[cfg(feature = "langs-extra")]
"go" => "go",
#[cfg(feature = "langs-extra")]
"java" => "java",
#[cfg(feature = "langs-extra")]
"c" | "h" | "cc" | "cpp" | "cxx" | "hpp" | "hh" | "hxx" => "cpp",
_ => return None,
};
Some(language)
}
#[must_use]
pub fn source_files(path: &Path) -> Vec<(PathBuf, &'static str)> {
ignore::WalkBuilder::new(path)
.build()
.filter_map(std::result::Result::ok)
.map(ignore::DirEntry::into_path)
.filter_map(|p| {
let ext = p.extension().and_then(std::ffi::OsStr::to_str)?;
let language = language_for_extension(ext)?;
Some((p, language))
})
.collect()
}
#[must_use]
pub fn source_files_in(path: &Path, allowed: &[String]) -> Vec<(PathBuf, &'static str)> {
source_files(path)
.into_iter()
.filter(|(_, language)| allowed.iter().any(|a| a == language))
.collect()
}
#[must_use]
pub fn rust_files(path: &Path) -> Vec<PathBuf> {
ignore::WalkBuilder::new(path)
.build()
.filter_map(std::result::Result::ok)
.map(ignore::DirEntry::into_path)
.filter(|p| p.extension().is_some_and(|ext| ext == "rs"))
.collect()
}
pub fn extract_symbols(source: &str, language: &str) -> Result<Vec<Symbol>> {
Ok(extract_structure(source, language)?.symbols)
}
pub fn extract_structure(source: &str, language: &str) -> Result<FileStructure> {
let spec =
grammar_spec(language).ok_or_else(|| Error::UnsupportedLanguage(language.to_string()))?;
let mut parser = Parser::new();
parser
.set_language(&(spec.language)())
.map_err(|e| Error::Parse(e.to_string()))?;
let tree = parser
.parse(source, None)
.ok_or_else(|| Error::Parse("tree-sitter produced no tree".to_string()))?;
Ok(walk(&spec, tree.root_node(), source.as_bytes()))
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
pub struct NameCollision {
pub name: String,
pub sites: Vec<(SymbolKind, usize)>,
}
impl NameCollision {
#[must_use]
pub fn same_kind(&self) -> bool {
self.sites
.iter()
.enumerate()
.any(|(i, (k, _))| self.sites[i + 1..].iter().any(|(k2, _)| k == k2))
}
#[must_use]
pub fn cross_kind(&self) -> bool {
self.sites.iter().any(|(k, _)| *k != self.sites[0].0)
}
}
#[must_use]
pub fn name_collisions(symbols: &[Symbol]) -> Vec<NameCollision> {
let mut by_name: std::collections::BTreeMap<&str, Vec<(SymbolKind, usize)>> =
std::collections::BTreeMap::new();
for s in symbols {
let sites = by_name.entry(&s.name).or_default();
if !sites.contains(&(s.kind, s.start_line)) {
sites.push((s.kind, s.start_line));
}
}
by_name
.into_iter()
.filter(|(_, sites)| sites.len() > 1)
.map(|(name, mut sites)| {
sites.sort_by_key(|(_, line)| *line);
NameCollision {
name: name.to_string(),
sites,
}
})
.collect()
}
fn walk(spec: &GrammarSpec, root: Node, bytes: &[u8]) -> FileStructure {
let mut symbols = Vec::new();
let mut calls = Vec::new();
let mut import_refs = Vec::new();
let mut stack: Vec<(Node, Option<String>, Vec<String>)> = vec![(root, None, Vec::new())];
while let Some((node, enclosing, scope)) = stack.pop() {
let mut inner = enclosing.clone();
if let Some(kind) = (spec.symbol_kind)(node, bytes) {
if let Some(name) = (spec.symbol_name)(node, bytes) {
symbols.push(Symbol {
name: name.clone(),
scope: scope.clone(),
kind,
start_line: node.start_position().row + 1,
end_line: node.end_position().row + 1,
tier: Tier::TreeSitter,
});
if (spec.is_function_kind)(node.kind()) {
inner = Some(name);
}
}
}
if (spec.is_call_kind)(node.kind()) {
if let (Some(caller), Some(callee)) = (&enclosing, (spec.callee_name)(node, bytes)) {
calls.push(CallSite {
caller: caller.clone(),
callee,
line: node.start_position().row + 1,
});
}
}
(spec.collect_imports)(node, bytes, &mut import_refs);
let child_scope = match (spec.scope_name)(node, bytes) {
Some(name) => {
let mut s = scope.clone();
s.push(name);
s
}
None => scope,
};
let mut cursor = node.walk();
for child in node.children(&mut cursor) {
stack.push((child, inner.clone(), child_scope.clone()));
}
}
symbols.sort_by_key(|symbol| symbol.start_line);
import_refs.sort();
import_refs.dedup();
FileStructure {
symbols,
calls,
import_refs,
}
}
pub(crate) fn field_name(node: Node, bytes: &[u8]) -> Option<String> {
node.child_by_field_name("name")
.and_then(|n| n.utf8_text(bytes).ok())
.map(str::to_string)
}
pub(crate) fn collect_path_idents(
node: Node,
bytes: &[u8],
anchors: &[&str],
out: &mut Vec<String>,
) {
let mut stack = vec![node];
while let Some(n) = stack.pop() {
if n.kind() == "identifier" {
if let Ok(text) = n.utf8_text(bytes) {
if !anchors.contains(&text) {
out.push(text.to_string());
}
}
}
let mut cursor = n.walk();
for child in n.children(&mut cursor) {
stack.push(child);
}
}
}
#[cfg(test)]
#[path = "extract_test.rs"]
mod extract_test;