use crate::ImportType;
use crate::models::{Language, SearchResult, Span, SymbolKind};
use crate::parsers::{DependencyExtractor, ImportInfo};
use anyhow::{Context, Result};
use tree_sitter::Parser;
const SYMQ_0: &str = r#"
(function_declaration
(identifier) @name) @function
"#;
const SYMQ_1: &str = r#"
(variable_declaration
(identifier) @name
(struct_declaration)) @struct
"#;
const SYMQ_2: &str = r#"
(variable_declaration
(identifier) @name
(enum_declaration)) @enum
"#;
const SYMQ_3: &str = r#"
(variable_declaration
"const"
(identifier) @name) @const
"#;
const SYMQ_4: &str = r#"
(variable_declaration
"var"
(identifier) @name) @var
"#;
const SYMQ_5: &str = r#"
(test_declaration
(string) @name) @test
"#;
static SYMBOL_QUERIES: crate::parsers::LanguageQueries =
crate::parsers::LanguageQueries::new(&[SYMQ_0, SYMQ_1, SYMQ_2, SYMQ_3, SYMQ_4, SYMQ_5]);
pub fn parse(path: &str, source: &str) -> Result<Vec<SearchResult>> {
let mut parser = Parser::new();
let language = tree_sitter_zig::LANGUAGE;
parser
.set_language(&language.into())
.context("Failed to set Zig language")?;
let tree = parser
.parse(source, None)
.context("Failed to parse Zig source")?;
let root_node = tree.root_node();
let table = SYMBOL_QUERIES.run(&language.into(), &root_node, source)?;
let mut symbols = Vec::new();
symbols.extend(extract_functions(source, &table)?);
symbols.extend(extract_structs(source, &table)?);
symbols.extend(extract_enums(source, &table)?);
symbols.extend(extract_constants(source, &table)?);
symbols.extend(extract_variables(source, &table)?);
symbols.extend(extract_tests(source, &table)?);
for symbol in &mut symbols {
symbol.path = path.to_string();
symbol.lang = Language::Zig;
}
Ok(symbols)
}
fn extract_functions(
source: &str,
table: &crate::parsers::MatchTable<'_>,
) -> Result<Vec<SearchResult>> {
extract_symbols(source, table, 0, SymbolKind::Function, None)
}
fn extract_structs(
source: &str,
table: &crate::parsers::MatchTable<'_>,
) -> Result<Vec<SearchResult>> {
extract_symbols(source, table, 1, SymbolKind::Struct, None)
}
fn extract_enums(
source: &str,
table: &crate::parsers::MatchTable<'_>,
) -> Result<Vec<SearchResult>> {
extract_symbols(source, table, 2, SymbolKind::Enum, None)
}
fn extract_constants(
source: &str,
table: &crate::parsers::MatchTable<'_>,
) -> Result<Vec<SearchResult>> {
extract_symbols(source, table, 3, SymbolKind::Constant, None)
}
fn extract_variables(
source: &str,
table: &crate::parsers::MatchTable<'_>,
) -> Result<Vec<SearchResult>> {
extract_symbols(source, table, 4, SymbolKind::Variable, None)
}
fn extract_tests(
source: &str,
table: &crate::parsers::MatchTable<'_>,
) -> Result<Vec<SearchResult>> {
extract_symbols(source, table, 5, SymbolKind::Function, None)
}
fn extract_symbols(
source: &str,
table: &crate::parsers::MatchTable<'_>,
sub: usize,
kind: SymbolKind,
scope: Option<String>,
) -> Result<Vec<SearchResult>> {
let query = table.query();
let matches = table.sub(sub);
let mut symbols = Vec::new();
for match_ in matches {
let mut name = None;
let mut full_node = None;
for capture in &match_.captures {
let capture_name: &str = query.capture_names()[capture.index as usize];
if capture_name == "name" {
name = Some(
capture
.node
.utf8_text(source.as_bytes())
.unwrap_or("")
.to_string(),
);
} else {
full_node = Some(capture.node);
}
}
if let (Some(name), Some(node)) = (name, full_node) {
let span = node_to_span(&node);
let preview = extract_preview(source, &node);
symbols.push(SearchResult::new(
String::new(),
Language::Zig,
kind.clone(),
Some(name),
span,
scope.clone(),
preview,
));
}
}
Ok(symbols)
}
fn node_to_span(node: &tree_sitter::Node) -> Span {
let start = node.start_position();
let end = node.end_position();
Span::new(
start.row + 1, start.column,
end.row + 1,
end.column,
)
}
fn extract_preview(source: &str, node: &tree_sitter::Node) -> String {
crate::parsers::preview::extract_preview_for_node(source, node)
}
pub struct ZigDependencyExtractor;
impl DependencyExtractor for ZigDependencyExtractor {
fn extract_dependencies(source: &str) -> Result<Vec<ImportInfo>> {
let mut imports = Vec::new();
for (line_idx, line) in source.lines().enumerate() {
if let Some(import_path) = extract_zig_import_from_line(line) {
let import_type = classify_zig_import(&import_path);
let line_number = line_idx + 1;
imports.push(ImportInfo {
imported_path: import_path,
line_number,
import_type,
imported_symbols: None,
});
}
}
Ok(imports)
}
}
fn extract_zig_import_from_line(line: &str) -> Option<String> {
let import_start = line.find("@import(")?;
let after_import = &line[import_start + 8..];
let first_char = after_import.trim_start().chars().next()?;
if first_char != '"' && first_char != '\'' {
return None;
}
let quote_char = first_char;
let after_quote = &after_import[after_import.find(quote_char)? + 1..];
let end_quote = after_quote.find(quote_char)?;
let path = &after_quote[..end_quote];
Some(path.to_string())
}
fn classify_zig_import(import_path: &str) -> ImportType {
if import_path == "std" || import_path == "builtin" || import_path == "root" {
return ImportType::Stdlib;
}
if is_zig_file_import(import_path) {
return ImportType::Internal;
}
ImportType::External
}
pub fn is_zig_file_import(import_path: &str) -> bool {
import_path.starts_with("./")
|| import_path.starts_with("../")
|| import_path.ends_with(".zig")
|| import_path.ends_with(".zon")
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ZigModule {
pub dir: String,
pub name: String,
pub root: String,
}
pub fn parse_build_zig_modules(rel: &str, source: &str) -> Vec<ZigModule> {
let dir = crate::dependency_resolve::parent_dir(rel);
let quoted = |s: &str| -> Option<String> {
let s = s.trim_start().strip_prefix('"')?;
Some(s[..s.find('"')?].to_string())
};
let root_file = |stmt: &str| -> Option<String> {
let at = stmt.find(".root_source_file")?;
let rest = &stmt[at..];
let call = rest.find("path(")?;
quoted(&rest[call + "path(".len()..])
};
let mut named: Vec<(String, String)> = Vec::new();
let mut vars: std::collections::HashMap<String, String> = std::collections::HashMap::new();
let mut imports: Vec<(String, String)> = Vec::new();
for stmt in source.split(';') {
let trimmed = stmt.trim_start();
let var = trimmed
.strip_prefix("const ")
.or_else(|| trimmed.strip_prefix("var "))
.and_then(|r| r.split_once('='))
.map(|(name, _)| name.trim().to_string());
if let Some(path) = root_file(stmt) {
if let Some(at) = stmt.find("addModule(")
&& let Some(name) = quoted(&stmt[at + "addModule(".len()..])
{
named.push((name, path.clone()));
}
if let Some(var) = &var
&& (stmt.contains("addModule(") || stmt.contains("createModule("))
{
vars.insert(var.clone(), path);
}
}
let mut rest = stmt;
while let Some(at) = rest.find(".addImport(") {
rest = &rest[at + ".addImport(".len()..];
let Some(name) = quoted(rest) else { continue };
let after = &rest[rest.find(',').map_or(rest.len(), |i| i + 1)..];
let expr: String = after
.trim_start()
.chars()
.take_while(|c| c.is_alphanumeric() || *c == '_' || *c == '.')
.collect();
if let Some(var) = expr.rsplit('.').next().filter(|v| !v.is_empty()) {
imports.push((name, var.to_string()));
}
}
}
for (name, var) in imports {
if let Some(path) = vars.get(&var)
&& !named.iter().any(|(n, _)| *n == name)
{
named.push((name, path.clone()));
}
}
named
.into_iter()
.filter_map(|(name, path)| {
Some(ZigModule {
dir: dir.to_string(),
root: crate::dependency_resolve::fold_path(dir, &path)?,
name,
})
})
.collect()
}
pub fn find_zig_module<'a>(
name: &str,
rel: &str,
modules: &'a [ZigModule],
) -> Option<&'a ZigModule> {
modules
.iter()
.filter(|m| m.name == name && (m.dir.is_empty() || rel.starts_with(&format!("{}/", m.dir))))
.max_by_key(|m| m.dir.len())
}
pub fn resolve_zig_import_to_path(
import_path: &str,
current_file_path: Option<&str>,
) -> Option<String> {
if !is_zig_file_import(import_path) {
return None;
}
let current_file = current_file_path?;
crate::dependency_resolve::fold_path(
crate::dependency_resolve::parent_dir(current_file),
import_path,
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_function() {
let source = r#"
pub fn add(a: i32, b: i32) i32 {
return a + b;
}
"#;
let symbols = parse("test.zig", source).unwrap();
let func_symbols: Vec<_> = symbols
.iter()
.filter(|s| matches!(s.kind, SymbolKind::Function))
.collect();
assert_eq!(func_symbols.len(), 1);
assert_eq!(func_symbols[0].symbol.as_deref(), Some("add"));
}
#[test]
fn test_parse_struct() {
let source = r#"
const Point = struct {
x: f32,
y: f32,
};
"#;
let symbols = parse("test.zig", source).unwrap();
let struct_symbols: Vec<_> = symbols
.iter()
.filter(|s| matches!(s.kind, SymbolKind::Struct))
.collect();
assert_eq!(struct_symbols.len(), 1);
assert_eq!(struct_symbols[0].symbol.as_deref(), Some("Point"));
}
#[test]
fn test_parse_enum() {
let source = r#"
const Status = enum {
active,
inactive,
pending,
};
"#;
let symbols = parse("test.zig", source).unwrap();
let enum_symbols: Vec<_> = symbols
.iter()
.filter(|s| matches!(s.kind, SymbolKind::Enum))
.collect();
assert_eq!(enum_symbols.len(), 1);
assert_eq!(enum_symbols[0].symbol.as_deref(), Some("Status"));
}
#[test]
fn test_parse_constants() {
let source = r#"
const MAX_SIZE: usize = 100;
const DEFAULT_TIMEOUT: u32 = 30;
"#;
let symbols = parse("test.zig", source).unwrap();
let const_symbols: Vec<_> = symbols
.iter()
.filter(|s| matches!(s.kind, SymbolKind::Constant))
.collect();
assert_eq!(const_symbols.len(), 2);
assert!(
const_symbols
.iter()
.any(|s| s.symbol.as_deref() == Some("MAX_SIZE"))
);
assert!(
const_symbols
.iter()
.any(|s| s.symbol.as_deref() == Some("DEFAULT_TIMEOUT"))
);
}
#[test]
fn test_parse_test_declaration() {
let source = r#"
test "basic addition" {
const result = add(2, 3);
try std.testing.expect(result == 5);
}
"#;
let symbols = parse("test.zig", source).unwrap();
let test_symbols: Vec<_> = symbols
.iter()
.filter(|s| matches!(s.kind, SymbolKind::Function))
.filter(|s| s.symbol.as_deref().unwrap_or("").contains("basic addition"))
.collect();
let _ = test_symbols; }
#[test]
fn test_parse_pub_functions() {
let source = r#"
pub fn multiply(a: i32, b: i32) i32 {
return a * b;
}
fn divide(a: i32, b: i32) i32 {
return @divTrunc(a, b);
}
"#;
let symbols = parse("test.zig", source).unwrap();
let func_symbols: Vec<_> = symbols
.iter()
.filter(|s| matches!(s.kind, SymbolKind::Function))
.collect();
assert_eq!(func_symbols.len(), 2);
assert!(
func_symbols
.iter()
.any(|s| s.symbol.as_deref() == Some("multiply"))
);
assert!(
func_symbols
.iter()
.any(|s| s.symbol.as_deref() == Some("divide"))
);
}
#[test]
fn test_parse_struct_with_methods() {
let source = r#"
const Calculator = struct {
value: i32,
pub fn init(val: i32) Calculator {
return Calculator{ .value = val };
}
pub fn add(self: *Calculator, other: i32) void {
self.value += other;
}
};
"#;
let symbols = parse("test.zig", source).unwrap();
let struct_symbols: Vec<_> = symbols
.iter()
.filter(|s| matches!(s.kind, SymbolKind::Struct))
.collect();
assert_eq!(struct_symbols.len(), 1);
assert_eq!(struct_symbols[0].symbol.as_deref(), Some("Calculator"));
}
#[test]
fn test_parse_error_set() {
let source = r#"
const FileError = error{
AccessDenied,
FileNotFound,
OutOfMemory,
};
"#;
let symbols = parse("test.zig", source).unwrap();
let const_symbols: Vec<_> = symbols
.iter()
.filter(|s| matches!(s.kind, SymbolKind::Constant))
.collect();
assert!(
const_symbols
.iter()
.any(|s| s.symbol.as_deref() == Some("FileError"))
);
}
#[test]
fn test_parse_mixed_symbols() {
let source = r#"
const std = @import("std");
const MAX_BUFFER = 1024;
const Point = struct {
x: f32,
y: f32,
};
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
try stdout.print("Hello, World!\n", .{});
}
test "point creation" {
const p = Point{ .x = 1.0, .y = 2.0 };
try std.testing.expect(p.x == 1.0);
}
"#;
let symbols = parse("test.zig", source).unwrap();
assert!(symbols.len() >= 3);
let kinds: Vec<&SymbolKind> = symbols.iter().map(|s| &s.kind).collect();
assert!(kinds.contains(&&SymbolKind::Constant));
assert!(kinds.contains(&&SymbolKind::Struct));
assert!(kinds.contains(&&SymbolKind::Function));
}
#[test]
fn test_local_variables_included() {
let source = r#"
const GLOBAL_CONST = 100;
var globalVar: i32 = 50;
pub fn calculate(input: i32) i32 {
const localConst = 10;
var localVar: i32 = input * 2;
localVar += localConst;
return localVar;
}
test "variable types" {
const testConst = 5;
var testVar: i32 = 0;
testVar = testConst * 2;
try std.testing.expect(testVar == 10);
}
"#;
let symbols = parse("test.zig", source).unwrap();
let constants: Vec<_> = symbols
.iter()
.filter(|s| matches!(s.kind, SymbolKind::Constant))
.collect();
let variables: Vec<_> = symbols
.iter()
.filter(|s| matches!(s.kind, SymbolKind::Variable))
.collect();
assert!(
constants
.iter()
.any(|c| c.symbol.as_deref() == Some("GLOBAL_CONST"))
);
assert!(
constants
.iter()
.any(|c| c.symbol.as_deref() == Some("localConst"))
);
assert!(
constants
.iter()
.any(|c| c.symbol.as_deref() == Some("testConst"))
);
assert!(
variables
.iter()
.any(|v| v.symbol.as_deref() == Some("globalVar"))
);
assert!(
variables
.iter()
.any(|v| v.symbol.as_deref() == Some("localVar"))
);
assert!(
variables
.iter()
.any(|v| v.symbol.as_deref() == Some("testVar"))
);
for _constant in &constants {
}
for _variable in &variables {
}
}
#[test]
fn test_extract_zig_imports() {
let source = r#"
const std = @import("std");
const builtin = @import("builtin");
const utils = @import("./utils.zig");
const helpers = @import("../helpers.zig");
const zap = @import("zap");
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
try stdout.print("Hello, World!\n", .{});
}
"#;
let deps = ZigDependencyExtractor::extract_dependencies(source).unwrap();
assert!(
deps.len() >= 4,
"Should extract at least 4 imports, got {}",
deps.len()
);
assert!(
deps.iter()
.any(|d| d.imported_path == "std" && matches!(d.import_type, ImportType::Stdlib))
);
assert!(
deps.iter().any(
|d| d.imported_path == "builtin" && matches!(d.import_type, ImportType::Stdlib)
)
);
assert!(
deps.iter().any(|d| d.imported_path == "./utils.zig"
&& matches!(d.import_type, ImportType::Internal))
);
assert!(deps.iter().any(|d| d.imported_path == "../helpers.zig"
&& matches!(d.import_type, ImportType::Internal)));
assert!(
deps.iter()
.any(|d| d.imported_path == "zap" && matches!(d.import_type, ImportType::External))
);
}
#[cfg(test)]
mod resolution_tests {
use super::*;
#[test]
fn test_resolve_zig_import_same_directory() {
let result = resolve_zig_import_to_path("./utils.zig", Some("/project/src/main.zig"));
assert!(result.is_some());
let path = result.unwrap();
assert!(path.contains("src") && path.ends_with("utils.zig"));
}
#[test]
fn test_resolve_zig_import_subdirectory() {
let result =
resolve_zig_import_to_path("./utils/helpers.zig", Some("/project/src/main.zig"));
assert!(result.is_some());
let path = result.unwrap();
assert!(
path.contains("src") && path.contains("utils") && path.ends_with("helpers.zig")
);
}
#[test]
fn test_resolve_zig_import_parent_directory() {
let result =
resolve_zig_import_to_path("../common.zig", Some("/project/src/utils/main.zig"));
assert!(result.is_some());
let path = result.unwrap();
assert!(path.contains("src") && path.ends_with("common.zig"));
}
#[test]
fn test_resolve_zig_import_stdlib_returns_none() {
let result = resolve_zig_import_to_path("std", Some("/project/src/main.zig"));
assert!(result.is_none());
let result = resolve_zig_import_to_path("builtin", Some("/project/src/main.zig"));
assert!(result.is_none());
}
#[test]
fn test_resolve_zig_import_external_returns_none() {
let result = resolve_zig_import_to_path("zap", Some("/project/src/main.zig"));
assert!(result.is_none());
let result = resolve_zig_import_to_path("some_package", Some("/project/src/main.zig"));
assert!(result.is_none());
}
}
}