mod accessors;
mod capture;
mod inheritance;
mod methods;
mod properties;
mod refs;
mod utils;
#[cfg(test)]
mod tests;
pub(crate) use capture::handle_groovy_capture;
use crate::models::{EntityKind, ParsedEntity, ReferenceIntent};
use accessors::synthesize_property_accessors;
use inheritance::{
build_type_declaration, extract_inheritance_intents, try_extract_type_declaration,
};
use methods::{
find_method_body_end, try_extract_def_method, try_extract_typed_method,
try_extract_typed_method_multiline,
};
use properties::{GroovyPropertyDecl, try_extract_property};
use refs::{body_on_declaration_line, extract_method_calls, scan_line_for_calls};
use utils::{build_fqn, extract_package, extract_preceding_docstring, strip_comments_line};
pub(crate) fn extract_entities_groovy(
source: &str,
file_path: &str,
repo_name: &str,
) -> Vec<ParsedEntity> {
let mut entities: Vec<ParsedEntity> = vec![];
let package = extract_package(source);
let mut known_lines = std::collections::HashSet::new();
postprocess_tree_sitter_entities(&mut entities, source, &package, &mut known_lines);
let mut scan = GroovyScan {
source,
file_path,
repo_name,
package: &package,
lines: source.lines().collect(),
known_lines,
scope_stack: Vec::new(),
brace_count: 0,
in_block_comment: false,
prop_decls: std::collections::HashMap::new(),
entities,
};
for (line_idx, line) in source.lines().enumerate() {
scan.process_line(line_idx, line);
}
let GroovyScan {
mut entities,
prop_decls,
..
} = scan;
fix_method_end_lines(&mut entities, source);
synthesize_property_accessors(&mut entities, &package, file_path, repo_name, &prop_decls);
assign_method_call_references(source, &mut entities);
entities
}
fn postprocess_tree_sitter_entities(
entities: &mut [ParsedEntity],
source: &str,
package: &Option<String>,
known_lines: &mut std::collections::HashSet<usize>,
) {
for entity in entities.iter_mut() {
known_lines.insert(entity.start_line);
if entity.kind == EntityKind::GroovyClass
&& let Some(line_content) = source.lines().nth(entity.start_line.saturating_sub(1))
{
let trimmed = line_content.trim();
if trimmed.starts_with("trait ") || trimmed.contains(" trait ") {
entity.kind = EntityKind::GroovyTrait;
}
}
if let Some(pkg) = package {
entity.fqn = match entity.kind {
EntityKind::GroovyClass
| EntityKind::GroovyInterface
| EntityKind::GroovyTrait
| EntityKind::GroovyEnum => format!("{}.{}", pkg, entity.name),
_ => continue,
};
}
}
}
struct GroovyScan<'a> {
source: &'a str,
file_path: &'a str,
repo_name: &'a str,
package: &'a Option<String>,
lines: Vec<&'a str>,
known_lines: std::collections::HashSet<usize>,
scope_stack: Vec<(String, usize)>,
brace_count: usize,
in_block_comment: bool,
prop_decls: std::collections::HashMap<(String, String), GroovyPropertyDecl>,
entities: Vec<ParsedEntity>,
}
impl<'a> GroovyScan<'a> {
fn process_line(&mut self, line_idx: usize, line: &'a str) {
let line_num = line_idx + 1;
let effective = strip_comments_line(line, &mut self.in_block_comment);
let opened = effective.matches('{').count();
let closed = effective.matches('}').count();
let prev_brace_count = self.brace_count;
self.brace_count += opened;
let mut early_pop = false;
if closed > opened {
let temp_brace = self.brace_count.saturating_sub(closed);
while let Some((_, entry_brace)) = self.scope_stack.last() {
if temp_brace < *entry_brace {
self.scope_stack.pop();
early_pop = true;
} else {
break;
}
}
}
if effective.is_empty() {
return;
}
self.try_type_declaration(effective.as_ref(), line_num);
let enclosing = self.scope_stack.last().map(|(n, _)| n.clone());
if self.try_methods(effective.as_ref(), line_num, &enclosing) {
return;
}
self.try_property(effective.as_ref(), line_num, &enclosing, prev_brace_count);
self.brace_count = self.brace_count.saturating_sub(closed);
if !early_pop {
while let Some((_, entry_brace)) = self.scope_stack.last() {
if self.brace_count < *entry_brace {
self.scope_stack.pop();
} else {
break;
}
}
}
}
fn try_type_declaration(&mut self, effective: &str, line_num: usize) {
if !self.known_lines.contains(&line_num)
&& let Some((name, kind)) = try_extract_type_declaration(effective)
{
let fqn = if let Some(pkg) = self.package {
format!("{}.{}", pkg, name)
} else {
name.clone()
};
let current_brace = self.brace_count;
let decl_text = build_type_declaration(self.source, line_num - 1)
.unwrap_or_else(|| effective.to_string());
let inheritance_intents = extract_inheritance_intents(&decl_text, &kind, line_num);
let docstring = extract_preceding_docstring(&self.lines, line_num - 1);
let mut new_entity = ParsedEntity::new(
&name,
kind,
&fqn,
None,
docstring,
"groovy",
self.file_path,
line_num,
line_num,
None,
self.repo_name,
);
new_entity.reference_intents.extend(inheritance_intents);
self.entities.push(new_entity);
self.scope_stack.push((name, current_brace));
}
}
fn try_methods(
&mut self,
effective: &str,
line_num: usize,
enclosing: &Option<String>,
) -> bool {
if self.known_lines.contains(&line_num) {
return false;
}
let line_idx = line_num - 1;
if let Some((method_name, signature)) = try_extract_def_method(effective) {
let fqn = build_fqn(self.package, enclosing, &method_name);
let docstring = extract_preceding_docstring(&self.lines, line_idx);
self.entities.push(ParsedEntity::new(
&method_name,
EntityKind::GroovyMethod,
&fqn,
Some(signature),
docstring,
"groovy",
self.file_path,
line_num,
line_num,
enclosing.clone(),
self.repo_name,
));
return true;
}
if let Some((method_name, _signature)) = try_extract_typed_method(effective) {
if method_name.contains('.')
|| method_name.chars().all(|c| c.is_uppercase() || c == '_')
{
return true;
}
let sig_end = effective.find('{').unwrap_or(effective.len());
let signature_full = effective[..sig_end].trim().to_string();
let fqn = build_fqn(self.package, enclosing, &method_name);
let docstring = extract_preceding_docstring(&self.lines, line_idx);
self.entities.push(ParsedEntity::new(
&method_name,
EntityKind::GroovyMethod,
&fqn,
Some(signature_full),
docstring,
"groovy",
self.file_path,
line_num,
line_num,
enclosing.clone(),
self.repo_name,
));
return true;
}
if let Some((method_name, method_start_line)) =
try_extract_typed_method_multiline(self.source, line_idx)
&& !method_name.contains('.')
{
let fqn = build_fqn(self.package, enclosing, &method_name);
let docstring = extract_preceding_docstring(&self.lines, method_start_line - 1);
self.entities.push(ParsedEntity::new(
&method_name,
EntityKind::GroovyMethod,
&fqn,
None,
docstring,
"groovy",
self.file_path,
method_start_line,
line_num,
enclosing.clone(),
self.repo_name,
));
return true;
}
false
}
fn try_property(
&mut self,
effective: &str,
line_num: usize,
enclosing: &Option<String>,
prev_brace_count: usize,
) {
let at_type_body_depth = self
.scope_stack
.last()
.is_some_and(|(_, entry_brace)| self.brace_count == *entry_brace);
let at_script_level = self.scope_stack.is_empty() && prev_brace_count == 0;
if !(at_type_body_depth || at_script_level) || self.known_lines.contains(&line_num) {
return;
}
let Some(prop_decl) = try_extract_property(effective) else {
return;
};
self.push_property(prop_decl, line_num, enclosing);
}
fn push_property(
&mut self,
prop_decl: GroovyPropertyDecl,
line_num: usize,
enclosing: &Option<String>,
) {
let fqn = build_fqn(self.package, enclosing, &prop_decl.name);
let docstring = extract_preceding_docstring(&self.lines, line_num - 1);
let enclosing_for_prop = enclosing.clone();
let name_clone = prop_decl.name.clone();
let enc_clone = enclosing_for_prop.clone();
self.entities.push(ParsedEntity::new(
&prop_decl.name,
EntityKind::GroovyProperty,
&fqn,
None,
docstring,
"groovy",
self.file_path,
line_num,
line_num,
enclosing_for_prop,
self.repo_name,
));
if let Some(enc) = enc_clone {
self.prop_decls.insert((enc, name_clone), prop_decl);
}
}
}
fn fix_method_end_lines(entities: &mut [ParsedEntity], source: &str) {
for entity in entities.iter_mut() {
if entity.kind == EntityKind::GroovyMethod
&& entity.end_line == entity.start_line
&& let Some(end_line) = find_method_body_end(source, entity.start_line)
&& end_line > entity.start_line
{
entity.end_line = end_line;
}
}
}
fn assign_method_call_references(source: &str, entities: &mut [ParsedEntity]) {
let mut method_spans: Vec<(usize, usize, usize)> = entities
.iter()
.enumerate()
.filter(|(_, e)| {
matches!(
e.kind,
EntityKind::GroovyMethod | EntityKind::GroovyFunction
)
})
.map(|(i, e)| (e.start_line, e.end_line, i))
.collect();
method_spans.sort_by_key(|(s, _, _)| *s);
let refs = extract_method_calls(source, entities);
for method_ref in refs {
if let ReferenceIntent::Call { line, .. } = method_ref
&& let Some(m_eidx) = innermost_method(&method_spans, line)
&& entities[m_eidx].start_line != line
{
entities[m_eidx].reference_intents.push(method_ref);
}
}
let lines: Vec<&str> = source.lines().collect();
for &(start, _, m_eidx) in &method_spans {
let Some(body) = lines
.get(start.wrapping_sub(1))
.and_then(|line| body_on_declaration_line(line, &entities[m_eidx].name))
else {
continue;
};
let mut calls = Vec::new();
scan_line_for_calls(body.trim(), start, &mut calls);
entities[m_eidx].reference_intents.extend(calls);
}
}
fn innermost_method(method_spans: &[(usize, usize, usize)], line: usize) -> Option<usize> {
method_spans
.iter()
.filter(|(start, end, _)| line >= *start && line <= *end)
.min_by_key(|(start, end, _)| end.saturating_sub(*start))
.map(|&(_, _, idx)| idx)
}